@agentuity/opencode 1.0.1 → 1.0.3

package/src/plugin/plugin.ts

@@ -63,21 +63,6 @@ You are running inside an Agentuity Sandbox (ID: ${SANDBOX_ID}).
 // Agents that should receive sandbox context in their prompts
 const SANDBOX_AWARE_AGENTS: AgentRole[] = ['lead', 'builder', 'architect'];
 
-// Agent display names for @mentions
-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',
-	reasoner: '@Agentuity Coder Reasoner',
-	product: '@Agentuity Coder Product',
-};
-
 export async function createCoderPlugin(ctx: PluginInput): Promise<Hooks> {
 	ctx.client.app.log({
 		body: {
@@ -94,7 +79,6 @@ export async function createCoderPlugin(ctx: PluginInput): Promise<Hooks> {
 	const toolHooks = createToolHooks(ctx, coderConfig);
 	const keywordHooks = createKeywordHooks(ctx, coderConfig);
 	const paramsHooks = createParamsHooks(ctx, coderConfig);
-	const cadenceHooks = createCadenceHooks(ctx, coderConfig);
 	const tmuxManager = coderConfig.tmux?.enabled
 		? new TmuxSessionManager(ctx, coderConfig.tmux, {
 				onLog: (message) =>
@@ -125,9 +109,37 @@ export async function createCoderPlugin(ctx: PluginInput): Promise<Hooks> {
 			: undefined,
 	});
 
+	// Recover any background tasks from previous sessions
+	// This allows tasks to survive plugin restarts
+	void backgroundManager
+		.recoverTasks()
+		.then((count) => {
+			if (count > 0) {
+				ctx.client.app.log({
+					body: {
+						service: 'agentuity-coder',
+						level: 'info',
+						message: `Recovered ${count} background task(s) from previous sessions`,
+					},
+				});
+			}
+		})
+		.catch((error) => {
+			ctx.client.app.log({
+				body: {
+					service: 'agentuity-coder',
+					level: 'warn',
+					message: `Failed to recover background tasks: ${error}`,
+				},
+			});
+		});
+
+	// Create hooks that need backgroundManager for task reference injection during compaction
+	const cadenceHooks = createCadenceHooks(ctx, coderConfig, backgroundManager);
+
 	// 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 sessionMemoryHooks = createSessionMemoryHooks(ctx, coderConfig, backgroundManager);
 
 	const configHandler = createConfigHandler(coderConfig);
 
@@ -228,8 +240,10 @@ function createConfigHandler(
 		// Validate merged configs and warn about mismatches
 		validateAndWarnConfigs(mergedAgents);
 
-		// In sandbox, allow all permissions without prompts
+		// Permission configuration for external directories
+		// Memory agent and other operations may need to write temp files for CLI piping
 		if (IN_SANDBOX) {
+			// In sandbox, allow all permissions without prompts
 			config.permission = {
 				'*': 'allow',
 				external_directory: {
@@ -237,6 +251,26 @@ function createConfigHandler(
 					'*': 'allow',
 				},
 			};
+		} else {
+			// For non-sandbox environments, auto-allow temp directory writes
+			// This prevents blocking prompts when Memory agent writes large JSON for CLI piping
+			const existingPermissions = (config.permission as Record<string, unknown>) ?? {};
+			const existingExternalDir =
+				(existingPermissions.external_directory as Record<string, string>) ?? {};
+
+			// Normalize TMPDIR: strip trailing slashes, then append /**
+			const tmpdir = process.env.TMPDIR?.replace(/\/+$/, '');
+			const tmpdirPattern = tmpdir ? `${tmpdir}/**` : null;
+
+			config.permission = {
+				...existingPermissions,
+				external_directory: {
+					...existingExternalDir,
+					'/tmp/**': 'allow',
+					// Also allow OS-specific temp directories
+					...(tmpdirPattern ? { [tmpdirPattern]: 'allow' } : {}),
+				},
+			};
 		}
 
 		config.command = {
@@ -280,6 +314,7 @@ function createAgentConfigs(
 			...(agent.maxSteps !== undefined ? { maxSteps: agent.maxSteps } : {}),
 			...(agent.reasoningEffort ? { reasoningEffort: agent.reasoningEffort } : {}),
 			...(agent.thinking ? { thinking: agent.thinking } : {}),
+			...(agent.hidden ? { hidden: agent.hidden } : {}),
 		};
 	}
 
@@ -303,7 +338,6 @@ You are the Agentuity Coder Lead agent orchestrating the Agentuity Coder team.
 - **@Agentuity Coder Memory**: Store context, remember decisions
 - **@Agentuity Coder Reasoner**: Extract structured conclusions, resolve conflicts, surface corrections
 - **@Agentuity Coder Expert**: Agentuity CLI and cloud services specialist
-- **@Agentuity Coder Planner**: Deep planning for complex architecture decisions
 - **@Agentuity Coder Runner**: Run lint/build/test commands, returns structured results
 - **@Agentuity Coder Product**: Clarify requirements, validate features, track progress
 
@@ -459,7 +493,6 @@ You are the Agentuity Coder Lead in **Cadence mode** — a long-running autonomo
 - **@Agentuity Coder Memory**: Store context, remember decisions, checkpoints
 - **@Agentuity Coder Reasoner**: Extract structured conclusions, resolve conflicts, surface corrections
 - **@Agentuity Coder Expert**: Agentuity CLI and cloud services specialist
-- **@Agentuity Coder Planner**: Deep planning for complex architecture decisions
 - **@Agentuity Coder Runner**: Run lint/build/test commands, returns structured results
 - **@Agentuity Coder Product**: Clarify requirements, validate features, track progress, Cadence briefings
 
@@ -468,33 +501,52 @@ $ARGUMENTS
 
 ## Cadence Workflow
 
-1. **Initialize loop state**:
+1. **FIRST: Establish PRD with Product** (REQUIRED):
+   - Ask @Agentuity Coder Product to establish/validate the PRD for this task
+   - Product will check for existing PRD or create one
+   - This defines "what" we're building and success criteria
+
+2. **Initialize loop state**:
    - Generate loop ID (format: \`lp_short_name_01\`)
    - Store in KV: \`agentuity cloud kv set agentuity-opencode-tasks "loop:{loopId}:state" '{...}'\`
+   - Link session planning to PRD via \`prdKey\`
 
-2. **Each iteration**:
+3. **Each iteration**:
    - Ask @Agentuity Coder Memory for relevant context
    - Use @Agentuity Coder Scout to understand what's needed
-   - For complex planning, consult @Agentuity Coder Planner
+   - For complex planning, use extended thinking (ultrathink) — ground in PRD requirements
    - Delegate implementation to **@Agentuity Coder Architect** (preferred for Cadence)
    - Have @Agentuity Coder Reviewer verify the work
    - Tell @Agentuity Coder Memory to store checkpoint
 
-3. **When truly complete**, output:
+4. **When truly complete**, output:
 \`\`\`
 <promise>DONE</promise>
 \`\`\`
 
-4. **Tell @Agentuity Coder Memory to memorialize** the completed session
+5. **Finalize**:
+   - Tell @Agentuity Coder Product to update the PRD with completed work
+   - Tell @Agentuity Coder Memory to memorialize the session
 
 ## Guidelines
+- **Product first** — Always establish PRD before starting work
 - **Use Architect for implementation** — Architect has GPT Codex with maximum reasoning, ideal for autonomous work
 - Use regular Builder only for trivial fixes within an iteration
 - Ask Memory for context at each iteration start
 - Store checkpoints at each iteration end
-- If stuck on architecture, consult Planner before trying more approaches
+- If stuck on architecture, use extended thinking (ultrathink) for deep planning
 - Use @Agentuity Coder Expert for sandbox/cloud operations
-- Respect max iterations (50 default)`,
+- Respect max iterations (50 default)
+
+## Lead-of-Leads (Parallel Work)
+If the task has **independent workstreams** that can run in parallel (e.g., "build auth, payments, and notifications"):
+1. Ask @Agentuity Coder Product to create PRD with workstreams
+2. Spawn child Leads via \`agentuity_background_task\` for each workstream
+3. Each child Lead claims a workstream, works autonomously, marks done when complete
+4. Monitor progress via PRD workstream status
+5. Do integration work when all children complete
+
+**Don't use Lead-of-Leads for:** small tasks, sequential work, or work requiring tight coordination.`,
 			agent: 'Agentuity Coder Lead',
 			argumentHint: 'build the new auth feature with tests',
 		},
@@ -539,46 +591,6 @@ function createTools(backgroundManager: BackgroundManager): Hooks['tool'] {
 	// Use the schema from @opencode-ai/plugin's tool helper to avoid Zod version mismatches
 	const s = tool.schema;
 
-	const coderDelegate = tool({
-		description: `Delegate a task to a specialized Agentuity Coder agent.
-
-Use this to:
-- Scout: Explore codebase, find patterns, research documentation
-- 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
-- Reasoner: Extract structured conclusions, resolve conflicts, surface corrections
-- Expert: Get help with Agentuity CLI and cloud services
-- Planner: Strategic advisor for complex architecture and deep planning (read-only)
-- Runner: Execute lint/build/test/typecheck/format commands, returns structured results`,
-		args: {
-			agent: s
-				.enum([
-					'scout',
-					'builder',
-					'architect',
-					'reviewer',
-					'memory',
-					'reasoner',
-					'expert',
-					'planner',
-					'runner',
-				])
-				.describe('Which agent to delegate to'),
-			task: s.string().describe('Clear description of the task'),
-			context: s.string().optional().describe('Additional context from previous tasks'),
-		},
-		async execute(args) {
-			const mention = AGENT_MENTIONS[args.agent as AgentRole];
-			let prompt = `${mention}\n\n## Task\n${args.task}`;
-			if (args.context) {
-				prompt = `${mention}\n\n## Context\n${args.context}\n\n## Task\n${args.task}`;
-			}
-			return `To delegate this task, use the Task tool with this prompt:\n\n${prompt}\n\nThe ${args.agent} agent will handle this task.`;
-		},
-	});
-
 	const backgroundTask = tool({
 		description: `Launch a task to run in the background. Use this for parallel execution of multiple independent tasks.
 
@@ -597,9 +609,9 @@ IMPORTANT: Use this tool instead of the 'task' tool when:
 					'memory',
 					'reasoner',
 					'expert',
-					'planner',
 					'runner',
 					'product',
+					'monitor',
 				])
 				.describe('Agent role to run the task'),
 			task: s.string().describe('Task prompt to run in the background'),
@@ -672,6 +684,49 @@ IMPORTANT: Use this tool instead of the 'task' tool when:
 		},
 	});
 
+	const backgroundInspect = tool({
+		description: `Inspect a background task to see its session messages and current state. Useful for debugging or checking what a child agent is doing.`,
+		args: {
+			task_id: s.string().describe('Background task ID to inspect'),
+		},
+		async execute(args) {
+			const inspection = await backgroundManager.inspectTask(args.task_id);
+			if (!inspection) {
+				return JSON.stringify({
+					taskId: args.task_id,
+					status: 'unknown',
+					found: false,
+					error: 'Task not found or session no longer exists.',
+				});
+			}
+
+			// Extract last few messages for summary
+			const messages = inspection.messages ?? [];
+			const lastMessages = messages
+				.slice(-3)
+				.map((m) => {
+					const parts = m.parts ?? [];
+					const textParts = parts.filter(
+						(p: unknown) => (p as { type?: string }).type === 'text'
+					);
+					return textParts
+						.map((p: unknown) => ((p as { text?: string }).text ?? '').slice(0, 200))
+						.join(' ')
+						.slice(0, 300);
+				})
+				.filter(Boolean);
+
+			return JSON.stringify({
+				taskId: inspection.taskId,
+				status: inspection.status,
+				found: true,
+				messageCount: messages.length,
+				lastMessages,
+				lastActivity: inspection.lastActivity,
+			});
+		},
+	});
+
 	const memoryShare = tool({
 		description: `Share memory content publicly via Agentuity Cloud Streams.
 
@@ -702,10 +757,11 @@ Returns the public URL that can be copied and used anywhere.`,
 			compress: s.boolean().optional().describe('Enable gzip compression'),
 			region: s.string().optional().describe('Cloud region (use, usc, usw). Default: usc'),
 		},
-		async execute(args) {
+		async execute(args, context) {
 			// Get the profile first - this ensures checkAuth() and CLI use the same profile
 			const profile = getCoderProfile();
 			const originalProfile = process.env.AGENTUITY_PROFILE;
+			const sessionId = context.sessionID;
 
 			try {
 				// Set profile before auth check so checkAuth reads the correct config
@@ -752,6 +808,8 @@ Returns the public URL that can be copied and used anywhere.`,
 					env: {
 						...process.env,
 						AGENTUITY_PROFILE: profile,
+						AGENTUITY_AGENT_MODE: 'opencode',
+						...(sessionId ? { AGENTUITY_OPENCODE_SESSION: sessionId } : {}),
 					},
 				});
 
@@ -810,10 +868,10 @@ Returns the public URL that can be copied and used anywhere.`,
 	});
 
 	return {
-		agentuity_coder_delegate: coderDelegate,
 		agentuity_background_task: backgroundTask,
 		agentuity_background_output: backgroundOutput,
 		agentuity_background_cancel: backgroundCancel,
+		agentuity_background_inspect: backgroundInspect,
 		agentuity_memory_share: memoryShare,
 	};
 }

package/src/services/auth.ts

@@ -27,6 +27,16 @@ const AGENTUITY_CONFIG_DIR = join(homedir(), '.config', 'agentuity');
 const DEFAULT_PROFILE = 'production.yaml';
 
 async function getProfilePath(): Promise<string> {
+	// Check AGENTUITY_PROFILE env var first (matches CLI behavior)
+	if (process.env.AGENTUITY_PROFILE) {
+		const envProfilePath = join(AGENTUITY_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(AGENTUITY_CONFIG_DIR, 'profile'));
 
 	if (await profileFile.exists()) {

package/src/tmux/executor.ts

@@ -1,6 +1,7 @@
 import type { PaneAction, WindowState, TmuxConfig } from './types';
 import { runTmuxCommand, runTmuxCommandSync } from './utils';
 import { spawn, spawnSync } from 'bun';
+import { getCoderProfile } from '../plugin/hooks/tools';
 
 /**
  * Escape a string for safe use in shell commands.
@@ -432,10 +433,14 @@ async function replacePane(
 	// Use exec to replace bash with opencode attach directly.
 	// This ensures signals go directly to opencode attach (no wrapper process).
 	// When opencode attach exits, the pane closes automatically (tmux remain-on-exit off).
-	// Use shellEscape to prevent shell injection via session IDs
+	// Use shellEscape to prevent shell injection via session IDs and profile
 	const escapedServerUrl = shellEscape(ctx.serverUrl);
 	const escapedSessionId = shellEscape(action.newSessionId);
-	const command = `exec opencode attach ${escapedServerUrl} --session ${escapedSessionId}`;
+	// Inject profile, session ID, and agent mode environment variables
+	const profile = getCoderProfile();
+	const escapedProfile = shellEscape(profile);
+	const envPrefix = `AGENTUITY_PROFILE=${escapedProfile} AGENTUITY_OPENCODE_SESSION=${escapedSessionId} AGENTUITY_AGENT_MODE=opencode`;
+	const command = `${envPrefix} exec opencode attach ${escapedServerUrl} --session ${escapedSessionId}`;
 	const result = await runTmuxCommand(['respawn-pane', '-k', '-t', action.paneId, command]);
 	if (!result.success) {
 		return { success: false, error: result.output };
@@ -473,10 +478,14 @@ async function spawnInAgentsWindow(
 	// Use exec to replace bash with opencode attach directly.
 	// This ensures signals go directly to opencode attach (no wrapper process).
 	// When opencode attach exits, the pane closes automatically (tmux remain-on-exit off).
-	// Use shellEscape to prevent shell injection via session IDs
+	// Use shellEscape to prevent shell injection via session IDs and profile
 	const escapedServerUrl = shellEscape(ctx.serverUrl);
 	const escapedSessionId = shellEscape(action.sessionId);
-	const command = `exec opencode attach ${escapedServerUrl} --session ${escapedSessionId}`;
+	// Inject profile, session ID, and agent mode environment variables
+	const profile = getCoderProfile();
+	const escapedProfile = shellEscape(profile);
+	const envPrefix = `AGENTUITY_PROFILE=${escapedProfile} AGENTUITY_OPENCODE_SESSION=${escapedSessionId} AGENTUITY_AGENT_MODE=opencode`;
+	const command = `${envPrefix} exec opencode attach ${escapedServerUrl} --session ${escapedSessionId}`;
 	const layout = 'tiled'; // Always use tiled layout for grid arrangement
 
 	// Check if we have a cached agents window ID and if it still exists

package/src/tools/index.ts

@@ -1,4 +1,3 @@
-export { delegateTool, DelegateArgsSchema, type DelegateArgs } from './delegate';
 export {
 	createBackgroundTools,
 	BackgroundTaskArgsSchema,

package/src/types.ts

@@ -23,10 +23,13 @@ export const AgentRoleSchema = z.enum([
 	'reviewer',
 	'memory',
 	'expert',
-	'planner',
+	'expert-backend',
+	'expert-frontend',
+	'expert-ops',
 	'runner',
 	'reasoner',
 	'product',
+	'monitor',
 ]);
 export type AgentRole = z.infer<typeof AgentRoleSchema>;
 

package/dist/agents/planner.d.ts

@@ -1,4 +0,0 @@
-import type { AgentDefinition } from './types';
-export declare const PLANNER_SYSTEM_PROMPT = "# Planner Agent\n\nYou are a strategic technical advisor with deep reasoning capabilities, operating as a specialized consultant within the Agentuity Coder team.\n\n## Context\n\nYou function as an on-demand specialist invoked by the Lead agent when complex analysis or architectural decisions require elevated reasoning. Each consultation is standalone\u2014treat every request as complete and self-contained since no clarifying dialogue is possible.\n\n## What You ARE / ARE NOT\n\n| You ARE | You ARE NOT |\n|---------|-------------|\n| Strategic technical advisor | Code implementer |\n| Architecture analyst | Direct file editor |\n| Deep reasoning specialist | Quick task executor |\n| Decision framework provider | Build/test runner |\n| Risk assessor | Project manager |\n\n## What You Do\n\nYour expertise covers:\n- Dissecting codebases to understand structural patterns and design choices\n- Formulating concrete, implementable technical recommendations\n- Architecting solutions and mapping out implementation roadmaps\n- Resolving intricate technical questions through systematic reasoning\n- Surfacing hidden issues and crafting preventive measures\n- Creating detailed, actionable plans that Builder can execute\n\n## Decision Framework\n\nApply pragmatic minimalism in all recommendations:\n\n**Bias toward simplicity**: The right solution is typically the least complex one that fulfills the actual requirements. Resist hypothetical future needs.\n\n**Leverage what exists**: Favor modifications to current code, established patterns, and existing dependencies over introducing new components. New libraries, services, or infrastructure require explicit justification.\n\n**Prioritize developer experience**: Optimize for readability, maintainability, and reduced cognitive load. Theoretical performance gains or architectural purity matter less than practical usability.\n\n**One clear path**: Present a single primary recommendation. Mention alternatives only when they offer substantially different trade-offs worth considering.\n\n**Match depth to complexity**: Quick questions get quick answers. Reserve thorough analysis for genuinely complex problems or explicit requests for depth.\n\n**Signal the investment**: Tag recommendations with estimated effort\u2014use Quick(<1h), Short(1-4h), Medium(1-2d), or Large(3d+) to set expectations.\n\n**Know when to stop**: \"Working well\" beats \"theoretically optimal.\" Identify what conditions would warrant revisiting with a more sophisticated approach.\n\n## Working With Tools\n\nYou are a **read-only** agent. You can:\n- Read files to understand code structure\n- Use glob/grep to find patterns\n- Fetch documentation\n\nYou **cannot** and **should not**:\n- Write or edit files\n- Run bash commands\n- Execute tests or builds\n- Make any modifications\n\nYour role is to analyze and recommend. Builder will execute your plans.\n\n## Response Structure\n\nOrganize your final answer in three tiers:\n\n### Essential (always include)\n\n**Bottom Line**: 2-3 sentences capturing your recommendation\n\n**Action Plan**: Numbered steps or checklist for implementation\n- Each step should be specific enough for Builder to execute\n- Include file paths, function names, and expected changes\n- Order steps by dependency (what must happen first)\n\n**Effort Estimate**: Using the Quick/Short/Medium/Large scale\n\n### Expanded (include when relevant)\n\n**Why This Approach**: Brief reasoning and key trade-offs considered\n\n**Watch Out For**: Risks, edge cases, and mitigation strategies\n\n**Dependencies**: What needs to exist before this work can begin\n\n### Edge Cases (only when genuinely applicable)\n\n**Escalation Triggers**: Specific conditions that would justify a more complex solution\n\n**Alternative Sketch**: High-level outline of the advanced path (not a full design)\n\n## Plan Format for Builder\n\nWhen creating implementation plans, use this structure:\n\n```markdown\n## Implementation Plan\n\n### Phase 1: [Name]\n**Effort**: Quick/Short/Medium/Large\n\n1. **[Step Name]**\n   - File: `path/to/file.ts`\n   - Action: [Create/Modify/Delete]\n   - Details: [Specific changes needed]\n\n2. **[Step Name]**\n   - File: `path/to/other.ts`\n   - Action: [Create/Modify/Delete]\n   - Details: [Specific changes needed]\n\n### Phase 2: [Name]\n...\n\n### Verification\n- [ ] [Specific test or check]\n- [ ] [Another verification step]\n```\n\n## Guiding Principles\n\n- **Actionable insight over exhaustive analysis**: Give Builder what they need to execute\n- **Depth matches complexity**: Simple questions get simple answers\n- **One recommendation**: Present the best path, not all possible paths\n- **Concrete specifics**: File paths, function names, exact changes\n- **Risk awareness**: Surface potential issues before they become problems\n\n## Collaboration\n\nYou work primarily with Lead and Builder/Architect:\n\n| Agent | How You Help Them |\n|-------|-------------------|\n| Lead | Provide strategic analysis, architecture decisions, detailed plans |\n| Builder or Architect | Create step-by-step implementation plans they can execute |\n| Reviewer | Offer architectural context for code reviews |\n| Scout | N/A (Scout gathers info for you to analyze) |\n\n## Critical Note\n\nYour response goes directly to the Lead agent who will delegate to Builder. Make your final message self-contained: a clear recommendation and actionable plan that Builder can execute immediately.\n\n**You are read-only.** Analyze, recommend, and plan\u2014but never attempt to modify code yourself.\n";
-export declare const plannerAgent: AgentDefinition;
-//# sourceMappingURL=planner.d.ts.map

package/dist/agents/planner.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"planner.d.ts","sourceRoot":"","sources":["../../src/agents/planner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C,eAAO,MAAM,qBAAqB,68KA8IjC,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,eAc1B,CAAC"}

package/dist/agents/planner.js

@@ -1,158 +0,0 @@
-export const PLANNER_SYSTEM_PROMPT = `# Planner Agent
-
-You are a strategic technical advisor with deep reasoning capabilities, operating as a specialized consultant within the Agentuity Coder team.
-
-## Context
-
-You function as an on-demand specialist invoked by the Lead agent when complex analysis or architectural decisions require elevated reasoning. Each consultation is standalone—treat every request as complete and self-contained since no clarifying dialogue is possible.
-
-## What You ARE / ARE NOT
-
-| You ARE | You ARE NOT |
-|---------|-------------|
-| Strategic technical advisor | Code implementer |
-| Architecture analyst | Direct file editor |
-| Deep reasoning specialist | Quick task executor |
-| Decision framework provider | Build/test runner |
-| Risk assessor | Project manager |
-
-## What You Do
-
-Your expertise covers:
-- Dissecting codebases to understand structural patterns and design choices
-- Formulating concrete, implementable technical recommendations
-- Architecting solutions and mapping out implementation roadmaps
-- Resolving intricate technical questions through systematic reasoning
-- Surfacing hidden issues and crafting preventive measures
-- Creating detailed, actionable plans that Builder can execute
-
-## Decision Framework
-
-Apply pragmatic minimalism in all recommendations:
-
-**Bias toward simplicity**: The right solution is typically the least complex one that fulfills the actual requirements. Resist hypothetical future needs.
-
-**Leverage what exists**: Favor modifications to current code, established patterns, and existing dependencies over introducing new components. New libraries, services, or infrastructure require explicit justification.
-
-**Prioritize developer experience**: Optimize for readability, maintainability, and reduced cognitive load. Theoretical performance gains or architectural purity matter less than practical usability.
-
-**One clear path**: Present a single primary recommendation. Mention alternatives only when they offer substantially different trade-offs worth considering.
-
-**Match depth to complexity**: Quick questions get quick answers. Reserve thorough analysis for genuinely complex problems or explicit requests for depth.
-
-**Signal the investment**: Tag recommendations with estimated effort—use Quick(<1h), Short(1-4h), Medium(1-2d), or Large(3d+) to set expectations.
-
-**Know when to stop**: "Working well" beats "theoretically optimal." Identify what conditions would warrant revisiting with a more sophisticated approach.
-
-## Working With Tools
-
-You are a **read-only** agent. You can:
-- Read files to understand code structure
-- Use glob/grep to find patterns
-- Fetch documentation
-
-You **cannot** and **should not**:
-- Write or edit files
-- Run bash commands
-- Execute tests or builds
-- Make any modifications
-
-Your role is to analyze and recommend. Builder will execute your plans.
-
-## Response Structure
-
-Organize your final answer in three tiers:
-
-### Essential (always include)
-
-**Bottom Line**: 2-3 sentences capturing your recommendation
-
-**Action Plan**: Numbered steps or checklist for implementation
-- Each step should be specific enough for Builder to execute
-- Include file paths, function names, and expected changes
-- Order steps by dependency (what must happen first)
-
-**Effort Estimate**: Using the Quick/Short/Medium/Large scale
-
-### Expanded (include when relevant)
-
-**Why This Approach**: Brief reasoning and key trade-offs considered
-
-**Watch Out For**: Risks, edge cases, and mitigation strategies
-
-**Dependencies**: What needs to exist before this work can begin
-
-### Edge Cases (only when genuinely applicable)
-
-**Escalation Triggers**: Specific conditions that would justify a more complex solution
-
-**Alternative Sketch**: High-level outline of the advanced path (not a full design)
-
-## Plan Format for Builder
-
-When creating implementation plans, use this structure:
-
-\`\`\`markdown
-## Implementation Plan
-
-### Phase 1: [Name]
-**Effort**: Quick/Short/Medium/Large
-
-1. **[Step Name]**
-   - File: \`path/to/file.ts\`
-   - Action: [Create/Modify/Delete]
-   - Details: [Specific changes needed]
-
-2. **[Step Name]**
-   - File: \`path/to/other.ts\`
-   - Action: [Create/Modify/Delete]
-   - Details: [Specific changes needed]
-
-### Phase 2: [Name]
-...
-
-### Verification
-- [ ] [Specific test or check]
-- [ ] [Another verification step]
-\`\`\`
-
-## Guiding Principles
-
-- **Actionable insight over exhaustive analysis**: Give Builder what they need to execute
-- **Depth matches complexity**: Simple questions get simple answers
-- **One recommendation**: Present the best path, not all possible paths
-- **Concrete specifics**: File paths, function names, exact changes
-- **Risk awareness**: Surface potential issues before they become problems
-
-## Collaboration
-
-You work primarily with Lead and Builder/Architect:
-
-| Agent | How You Help Them |
-|-------|-------------------|
-| Lead | Provide strategic analysis, architecture decisions, detailed plans |
-| Builder or Architect | Create step-by-step implementation plans they can execute |
-| Reviewer | Offer architectural context for code reviews |
-| Scout | N/A (Scout gathers info for you to analyze) |
-
-## Critical Note
-
-Your response goes directly to the Lead agent who will delegate to Builder. Make your final message self-contained: a clear recommendation and actionable plan that Builder can execute immediately.
-
-**You are read-only.** Analyze, recommend, and plan—but never attempt to modify code yourself.
-`;
-export const plannerAgent = {
-    role: 'planner',
-    id: 'ag-planner',
-    displayName: 'Agentuity Coder Planner',
-    description: 'Strategic technical advisor for complex architecture and deep planning. Read-only, high-reasoning specialist.',
-    defaultModel: 'openai/gpt-5.2',
-    systemPrompt: PLANNER_SYSTEM_PROMPT,
-    mode: 'subagent',
-    tools: {
-        exclude: ['write', 'edit', 'apply_patch', 'bash'], // Read-only agent
-    },
-    reasoningEffort: 'xhigh', // Maximum reasoning for GPT models
-    temperature: 0.1, // Low for consistent, deterministic analysis
-};
-//# sourceMappingURL=planner.js.map

package/dist/agents/planner.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"planner.js","sourceRoot":"","sources":["../../src/agents/planner.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,qBAAqB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8IpC,CAAC;AAEF,MAAM,CAAC,MAAM,YAAY,GAAoB;IAC5C,IAAI,EAAE,SAAS;IACf,EAAE,EAAE,YAAY;IAChB,WAAW,EAAE,yBAAyB;IACtC,WAAW,EACV,+GAA+G;IAChH,YAAY,EAAE,gBAAgB;IAC9B,YAAY,EAAE,qBAAqB;IACnC,IAAI,EAAE,UAAU;IAChB,KAAK,EAAE;QACN,OAAO,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,CAAC,EAAE,kBAAkB;KACrE;IACD,eAAe,EAAE,OAAO,EAAE,mCAAmC;IAC7D,WAAW,EAAE,GAAG,EAAE,6CAA6C;CAC/D,CAAC"}

package/dist/tools/delegate.d.ts

@@ -1,45 +0,0 @@
-import { z } from 'zod';
-export declare const DelegateArgsSchema: z.ZodObject<{
-    agent: z.ZodEnum<{
-        scout: "scout";
-        builder: "builder";
-        architect: "architect";
-        reviewer: "reviewer";
-        memory: "memory";
-        expert: "expert";
-        planner: "planner";
-        runner: "runner";
-        reasoner: "reasoner";
-        product: "product";
-    }>;
-    task: z.ZodString;
-    context: z.ZodOptional<z.ZodString>;
-    waitForResult: z.ZodDefault<z.ZodBoolean>;
-}, z.core.$strip>;
-export type DelegateArgs = z.infer<typeof DelegateArgsSchema>;
-export declare const delegateTool: {
-    name: string;
-    description: string;
-    args: z.ZodObject<{
-        agent: z.ZodEnum<{
-            scout: "scout";
-            builder: "builder";
-            architect: "architect";
-            reviewer: "reviewer";
-            memory: "memory";
-            expert: "expert";
-            planner: "planner";
-            runner: "runner";
-            reasoner: "reasoner";
-            product: "product";
-        }>;
-        task: z.ZodString;
-        context: z.ZodOptional<z.ZodString>;
-        waitForResult: z.ZodDefault<z.ZodBoolean>;
-    }, z.core.$strip>;
-    execute(args: DelegateArgs, _context: unknown): Promise<{
-        output: string;
-    }>;
-};
-export default delegateTool;
-//# sourceMappingURL=delegate.d.ts.map

package/dist/tools/delegate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"delegate.d.ts","sourceRoot":"","sources":["../../src/tools/delegate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;iBAqB7B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAiB9D,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;kBAoBJ,YAAY,YAAY,OAAO,GAAG,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;CAgBjF,CAAC;AAEF,eAAe,YAAY,CAAC"}