@doingdev/opencode-claude-manager-plugin 0.1.25 → 0.1.27

package/README.md

@@ -1,6 +1,6 @@
 # OpenCode Claude Manager Plugin
 
-This package provides an OpenCode plugin that lets an OpenCode-side manager agent orchestrate Claude Code sessions through a stable local bridge.
+This package provides an OpenCode plugin that lets an OpenCode-side agent hierarchy orchestrate Claude Code sessions through a stable local bridge.
 
 ## Overview
 
@@ -51,43 +51,43 @@ If you are testing locally, point OpenCode at the local package or plugin file u
 
 ## OpenCode tools
 
-### Session management
+### Engineer session
 
-- `claude_manager_send` — send a message to the persistent Claude Code session. Auto-creates on first call, resumes on subsequent calls.
+- `engineer_send` — send a message to the persistent Claude Code session. Auto-creates on first call, resumes on subsequent calls.
   - `message` (required) — the instruction to send.
   - `mode` — `"plan"` (read-only investigation) or `"free"` (default, normal execution with edits).
   - `freshSession` — set to `true` to clear the active session before sending. Use when switching to an unrelated task or when context is contaminated.
   - `model` — `"claude-opus-4-6"` (default, recommended for most coding work), `"claude-sonnet-4-6"`, or `"claude-sonnet-4-5"` (faster/lighter tasks).
   - `effort` — `"high"` (default), `"medium"` (lighter tasks), `"low"`, or `"max"` (especially hard problems).
-- `claude_manager_compact` — compress the active session context while preserving session state. Use before clearing when context is high but salvageable.
-- `claude_manager_clear` — drop the active session entirely; next send starts fresh.
-- `claude_manager_status` — get current session health: context %, turns, cost, session ID.
+- `engineer_compact` — compress the active session context while preserving session state. Use before clearing when context is high but salvageable.
+- `engineer_clear` — drop the active session entirely; next send starts fresh.
+- `engineer_status` — get current session health: context %, turns, cost, session ID.
 
 ### Git operations
 
-- `claude_manager_git_diff` — review all uncommitted changes (staged + unstaged).
-- `claude_manager_git_commit` — stage all changes and commit with a message.
-- `claude_manager_git_reset` — hard reset + clean (destructive).
+- `git_diff` — review all uncommitted changes (staged + unstaged).
+- `git_commit` — stage all changes and commit with a message.
+- `git_reset` — hard reset + clean (destructive).
 
 ### Inspection
 
-- `claude_manager_metadata` — inspect available Claude commands, skills, hooks, and settings.
-- `claude_manager_sessions` — list Claude sessions or inspect a saved transcript.
-- `claude_manager_runs` — list or inspect persisted manager run records (may be empty if tasks were sent directly via `claude_manager_send` rather than the run-tracking path).
+- `engineer_metadata` — inspect available Claude commands, skills, hooks, and settings.
+- `engineer_sessions` — list Claude sessions or inspect a saved transcript.
+- `engineer_runs` — list or inspect persisted manager run records (may be empty if tasks were sent directly via `engineer_send` rather than the run-tracking path).
 
 ### Tool approval
 
-- `claude_manager_approval_policy` — view the current tool approval policy.
-- `claude_manager_approval_decisions` — view recent tool approval decisions.
-- `claude_manager_approval_update` — add/remove rules, change default action, or enable/disable approval.
+- `approval_policy` — view the current tool approval policy.
+- `approval_decisions` — view recent tool approval decisions.
+- `approval_update` — add/remove rules, change default action, or enable/disable approval.
 
-## Plugin-provided agents and commands
+## Agent hierarchy
 
-When the plugin loads successfully, it also injects config entries through the OpenCode plugin `config` hook.
+The plugin registers a CTO → Manager → Engineer hierarchy through the OpenCode plugin `config` hook:
 
-- Primary agent: `claude-manager`
-- Subagent: `claude-manager-research`
-- Commands: `/claude-metadata`, `/claude-run`, `/claude-sessions`
+- **`cto`** (primary agent) — sets direction and orchestrates work by spawning `manager` subagents. Has read/search/web tools but does NOT operate Claude Code directly.
+- **`manager`** (subagent) — operates a Claude Code engineer through a persistent session. Has the full tool surface (`engineer_*`, `git_*`, `approval_*`) plus read/search/web tools for investigation.
+- **Engineer** — the Claude Code persistent session itself (not an OpenCode agent). Receives instructions from the manager, executes code changes, and reports results.
 
 These are added to OpenCode config at runtime by the plugin, so they do not require separate manual `opencode.json` entries.
 
@@ -95,27 +95,27 @@ These are added to OpenCode config at runtime by the plugin, so they do not requ
 
 Typical flow inside OpenCode:
 
-1. Inspect Claude capabilities with `claude_manager_metadata`.
-2. Delegate work with `claude_manager_send`.
-3. Review changes with `claude_manager_git_diff`, then commit or reset.
-4. Inspect saved Claude history with `claude_manager_sessions` or prior orchestration records with `claude_manager_runs`.
+1. Inspect Claude capabilities with `engineer_metadata`.
+2. Delegate work with `engineer_send`.
+3. Review changes with `git_diff`, then commit or reset.
+4. Inspect saved Claude history with `engineer_sessions` or prior orchestration records with `engineer_runs`.
 
 Example tasks:
 
 ```text
-Use claude_manager_send to implement the new validation logic in src/auth.ts, then review with claude_manager_git_diff.
+Use engineer_send to implement the new validation logic in src/auth.ts, then review with git_diff.
 ```
 
 Start a fresh session for an unrelated task:
 
 ```text
-Use claude_manager_send with freshSession:true to investigate the failing CI test in test/api.test.ts using mode:"plan".
+Use engineer_send with freshSession:true to investigate the failing CI test in test/api.test.ts using mode:"plan".
 ```
 
 Reclaim context mid-session:
 
 ```text
-Use claude_manager_compact to free up context, then continue with the next implementation step.
+Use engineer_compact to free up context, then continue with the next implementation step.
 ```
 
 ## Local Development

package/dist/plugin/agent-hierarchy.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Agent hierarchy configuration for the CTO + Engineer Wrapper architecture.
+ *
+ * CTO (cto)                     — main operator, directly controls Claude Code sessions
+ * Engineer Plan (engineer_plan) — thin subagent wrapper for read-only investigation
+ * Engineer Build (engineer_build) — thin subagent wrapper for implementation tasks
+ * Engineer                      — the Claude Code session itself (prompt only, no OpenCode agent)
+ */
+import type { ManagerPromptRegistry } from '../types/contracts.js';
+export declare const AGENT_CTO = "cto";
+export declare const AGENT_ENGINEER_PLAN = "engineer_plan";
+export declare const AGENT_ENGINEER_BUILD = "engineer_build";
+/** All restricted tool IDs (union of engineer + git + approval) */
+export declare const ALL_RESTRICTED_TOOL_IDS: readonly ["engineer_send", "engineer_compact", "engineer_clear", "engineer_status", "engineer_metadata", "engineer_sessions", "engineer_runs", "git_diff", "git_commit", "git_reset", "approval_policy", "approval_decisions", "approval_update"];
+type ToolPermission = 'allow' | 'ask' | 'deny';
+type AgentPermission = {
+    '*'?: ToolPermission;
+    read?: ToolPermission;
+    grep?: ToolPermission;
+    glob?: ToolPermission;
+    codesearch?: ToolPermission;
+    webfetch?: ToolPermission;
+    websearch?: ToolPermission;
+    /** OpenCode built-in: manage session todo list */
+    todowrite?: ToolPermission;
+    /** OpenCode built-in: read session todo list */
+    todoread?: ToolPermission;
+    /** OpenCode built-in: ask the user structured questions with options */
+    question?: ToolPermission;
+    bash?: ToolPermission | Record<string, ToolPermission>;
+    [tool: string]: ToolPermission | Record<string, ToolPermission> | undefined;
+};
+export declare function buildCtoAgentConfig(prompts: ManagerPromptRegistry): {
+    description: string;
+    mode: "primary";
+    color: string;
+    permission: AgentPermission;
+    prompt: string;
+};
+export declare function buildEngineerPlanAgentConfig(prompts: ManagerPromptRegistry): {
+    description: string;
+    mode: "subagent";
+    color: string;
+    permission: AgentPermission;
+    prompt: string;
+};
+export declare function buildEngineerBuildAgentConfig(prompts: ManagerPromptRegistry): {
+    description: string;
+    mode: "subagent";
+    color: string;
+    permission: AgentPermission;
+    prompt: string;
+};
+/** Deny all restricted tools at the global level so only designated agents can use them. */
+export declare function denyRestrictedToolsGlobally(permissions: Record<string, ToolPermission>): void;
+export {};

package/dist/plugin/agent-hierarchy.js

@@ -0,0 +1,127 @@
+/**
+ * Agent hierarchy configuration for the CTO + Engineer Wrapper architecture.
+ *
+ * CTO (cto)                     — main operator, directly controls Claude Code sessions
+ * Engineer Plan (engineer_plan) — thin subagent wrapper for read-only investigation
+ * Engineer Build (engineer_build) — thin subagent wrapper for implementation tasks
+ * Engineer                      — the Claude Code session itself (prompt only, no OpenCode agent)
+ */
+// ---------------------------------------------------------------------------
+// Agent names
+// ---------------------------------------------------------------------------
+export const AGENT_CTO = 'cto';
+export const AGENT_ENGINEER_PLAN = 'engineer_plan';
+export const AGENT_ENGINEER_BUILD = 'engineer_build';
+// ---------------------------------------------------------------------------
+// Tool IDs — grouped by domain
+// ---------------------------------------------------------------------------
+/** Engineer-facing session tools */
+const ENGINEER_TOOL_IDS = [
+    'engineer_send',
+    'engineer_compact',
+    'engineer_clear',
+    'engineer_status',
+    'engineer_metadata',
+    'engineer_sessions',
+    'engineer_runs',
+];
+/** Git tools */
+const GIT_TOOL_IDS = ['git_diff', 'git_commit', 'git_reset'];
+/** Approval tools */
+const APPROVAL_TOOL_IDS = [
+    'approval_policy',
+    'approval_decisions',
+    'approval_update',
+];
+/** All restricted tool IDs (union of engineer + git + approval) */
+export const ALL_RESTRICTED_TOOL_IDS = [
+    ...ENGINEER_TOOL_IDS,
+    ...GIT_TOOL_IDS,
+    ...APPROVAL_TOOL_IDS,
+];
+/** Tools available to engineer wrapper subagents (thin wrappers around Claude Code) */
+const ENGINEER_WRAPPER_TOOL_IDS = ['engineer_send', 'engineer_status'];
+// ---------------------------------------------------------------------------
+// Shared read-only tool permissions
+// ---------------------------------------------------------------------------
+const READONLY_TOOLS = {
+    read: 'allow',
+    grep: 'allow',
+    glob: 'allow',
+    codesearch: 'allow',
+    webfetch: 'allow',
+    websearch: 'allow',
+    todowrite: 'allow',
+    todoread: 'allow',
+    question: 'allow',
+};
+// ---------------------------------------------------------------------------
+// Permission builders
+// ---------------------------------------------------------------------------
+/** CTO: full operator — all restricted tools + read-only codebase tools. No edit, no bash. */
+function buildCtoPermissions() {
+    const allowed = {};
+    for (const toolId of ALL_RESTRICTED_TOOL_IDS) {
+        allowed[toolId] = 'allow';
+    }
+    return {
+        '*': 'deny',
+        ...READONLY_TOOLS,
+        ...allowed,
+    };
+}
+/** Engineer wrapper: only engineer_send + engineer_status. Everything else denied. */
+function buildEngineerWrapperPermissions() {
+    const denied = {};
+    for (const toolId of ALL_RESTRICTED_TOOL_IDS) {
+        denied[toolId] = 'deny';
+    }
+    const allowed = {};
+    for (const toolId of ENGINEER_WRAPPER_TOOL_IDS) {
+        allowed[toolId] = 'allow';
+    }
+    return {
+        '*': 'deny',
+        ...denied,
+        ...allowed,
+    };
+}
+// ---------------------------------------------------------------------------
+// Agent config builders
+// ---------------------------------------------------------------------------
+export function buildCtoAgentConfig(prompts) {
+    return {
+        description: 'CTO agent that directly operates Claude Code, gathers information, investigates, reviews, and commits. Can spawn engineer wrappers for parallel or isolated work.',
+        mode: 'primary',
+        color: '#D97757',
+        permission: buildCtoPermissions(),
+        prompt: prompts.ctoSystemPrompt,
+    };
+}
+export function buildEngineerPlanAgentConfig(prompts) {
+    return {
+        description: 'Thin wrapper that sends a read-only investigation task to Claude Code in plan mode and returns the result.',
+        mode: 'subagent',
+        color: '#D97757',
+        permission: buildEngineerWrapperPermissions(),
+        prompt: prompts.engineerPlanPrompt,
+    };
+}
+export function buildEngineerBuildAgentConfig(prompts) {
+    return {
+        description: 'Thin wrapper that sends an implementation task to Claude Code in free mode and returns the result.',
+        mode: 'subagent',
+        color: '#D97757',
+        permission: buildEngineerWrapperPermissions(),
+        prompt: prompts.engineerBuildPrompt,
+    };
+}
+// ---------------------------------------------------------------------------
+// Global permission helper
+// ---------------------------------------------------------------------------
+/** Deny all restricted tools at the global level so only designated agents can use them. */
+export function denyRestrictedToolsGlobally(permissions) {
+    for (const toolId of ALL_RESTRICTED_TOOL_IDS) {
+        permissions[toolId] ??= 'deny';
+    }
+}

package/dist/plugin/claude-manager.plugin.js

@@ -1,115 +1,20 @@
 import { tool } from '@opencode-ai/plugin';
 import { managerPromptRegistry } from '../prompts/registry.js';
+import { AGENT_CTO, AGENT_ENGINEER_BUILD, AGENT_ENGINEER_PLAN, buildCtoAgentConfig, buildEngineerBuildAgentConfig, buildEngineerPlanAgentConfig, denyRestrictedToolsGlobally, } from './agent-hierarchy.js';
 import { getOrCreatePluginServices } from './service-factory.js';
-const MANAGER_TOOL_IDS = [
-    'claude_manager_send',
-    'claude_manager_compact',
-    'claude_manager_git_diff',
-    'claude_manager_git_commit',
-    'claude_manager_git_reset',
-    'claude_manager_clear',
-    'claude_manager_status',
-    'claude_manager_metadata',
-    'claude_manager_sessions',
-    'claude_manager_runs',
-    'claude_manager_approval_policy',
-    'claude_manager_approval_decisions',
-    'claude_manager_approval_update',
-];
 export const ClaudeManagerPlugin = async ({ worktree }) => {
     const services = getOrCreatePluginServices(worktree);
     return {
         config: async (config) => {
             config.agent ??= {};
-            config.command ??= {};
             config.permission ??= {};
-            const globalPermissions = config.permission;
-            const managerPermissions = {};
-            const researchPermissions = {};
-            for (const toolId of MANAGER_TOOL_IDS) {
-                globalPermissions[toolId] ??= 'deny';
-                managerPermissions[toolId] = 'allow';
-                // Research agent can inspect but not send or modify
-                researchPermissions[toolId] =
-                    toolId === 'claude_manager_send' ||
-                        toolId === 'claude_manager_compact' ||
-                        toolId === 'claude_manager_git_commit' ||
-                        toolId === 'claude_manager_git_reset' ||
-                        toolId === 'claude_manager_clear' ||
-                        toolId === 'claude_manager_approval_update'
-                        ? 'deny'
-                        : 'allow';
-            }
-            config.agent['claude-manager'] ??= {
-                description: 'Primary agent that operates Claude Code through a persistent session, reviews work via git diff, and commits/resets changes.',
-                mode: 'primary',
-                color: '#D97757',
-                permission: {
-                    '*': 'deny',
-                    read: 'allow',
-                    grep: 'allow',
-                    glob: 'allow',
-                    codesearch: 'allow',
-                    webfetch: 'allow',
-                    websearch: 'allow',
-                    todowrite: 'allow',
-                    todoread: 'allow',
-                    question: 'allow',
-                    ...managerPermissions,
-                },
-                prompt: managerPromptRegistry.managerSystemPrompt,
-            };
-            config.agent['claude-manager-research'] ??= {
-                description: 'Subagent that inspects Claude metadata, prior sessions, and manager runs without changing repository state.',
-                mode: 'subagent',
-                color: 'info',
-                permission: {
-                    '*': 'deny',
-                    ...researchPermissions,
-                },
-                prompt: [
-                    'Focus on inspection and summarization.',
-                    'Use claude_manager_status, claude_manager_metadata, claude_manager_sessions, and claude_manager_runs to gather information.',
-                ].join(' '),
-            };
-            config.command['claude-run'] ??= {
-                description: 'Send a task to the persistent Claude Code session.',
-                agent: 'claude-manager',
-                subtask: true,
-                template: [
-                    'Use claude_manager_send to send the following task to Claude Code:',
-                    '$ARGUMENTS',
-                    'After it completes, review the result and use claude_manager_git_diff if changes were expected. Commit or reset accordingly.',
-                ].join('\n\n'),
-            };
-            config.command['claude-metadata'] ??= {
-                description: 'Inspect bundled Claude commands, skills, hooks, and agents.',
-                agent: 'claude-manager-research',
-                subtask: true,
-                template: [
-                    'Use claude_manager_metadata to inspect the current repository.',
-                    'Summarize Claude commands, skills, hooks, discovered agents, and important config files.',
-                ].join(' '),
-            };
-            config.command['claude-sessions'] ??= {
-                description: 'Inspect Claude session history and manager run records.',
-                agent: 'claude-manager-research',
-                subtask: true,
-                template: [
-                    'Use claude_manager_sessions and claude_manager_runs to inspect recent Claude activity for this repository.',
-                    'If the user provided extra arguments, use them to focus the inspection:',
-                    '$ARGUMENTS',
-                ].join('\n\n'),
-            };
-        },
-        'command.execute.before': async (input, output) => {
-            const commandText = buildCommandText(input.command, input.arguments);
-            if (commandText) {
-                output.parts = rewriteCommandParts(output.parts, commandText);
-            }
+            denyRestrictedToolsGlobally(config.permission);
+            config.agent[AGENT_CTO] ??= buildCtoAgentConfig(managerPromptRegistry);
+            config.agent[AGENT_ENGINEER_PLAN] ??= buildEngineerPlanAgentConfig(managerPromptRegistry);
+            config.agent[AGENT_ENGINEER_BUILD] ??= buildEngineerBuildAgentConfig(managerPromptRegistry);
         },
         tool: {
-            claude_manager_send: tool({
+            engineer_send: tool({
                 description: 'Send a message to the persistent Claude Code session. ' +
                     'Auto-creates a session on first call. Resumes the existing session on subsequent calls. ' +
                     'Returns the assistant response and current context health snapshot. ' +
@@ -320,7 +225,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     }, null, 2);
                 },
             }),
-            claude_manager_compact: tool({
+            engineer_compact: tool({
                 description: 'Compact the active Claude Code session to reclaim context space. ' +
                     'Sends /compact to the session, which compresses prior conversation while preserving state. ' +
                     'Use before clearing when context is high but the session still has useful state. ' +
@@ -350,7 +255,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     }, null, 2);
                 },
             }),
-            claude_manager_git_diff: tool({
+            git_diff: tool({
                 description: 'Run git diff to see all current changes (staged + unstaged) relative to HEAD.',
                 args: {
                     cwd: tool.schema.string().optional(),
@@ -361,7 +266,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     return JSON.stringify(result, null, 2);
                 },
             }),
-            claude_manager_git_commit: tool({
+            git_commit: tool({
                 description: 'Stage all changes and commit with the given message.',
                 args: {
                     message: tool.schema.string().min(1),
@@ -375,7 +280,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     return JSON.stringify(result, null, 2);
                 },
             }),
-            claude_manager_git_reset: tool({
+            git_reset: tool({
                 description: 'Run git reset --hard HEAD and git clean -fd to discard ALL uncommitted changes and untracked files.',
                 args: {
                     cwd: tool.schema.string().optional(),
@@ -386,7 +291,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     return JSON.stringify(result, null, 2);
                 },
             }),
-            claude_manager_clear: tool({
+            engineer_clear: tool({
                 description: 'Clear the active Claude Code session. The next send will start a fresh session. ' +
                     'Use when context is full, the session is confused, or starting a different task.',
                 args: {
@@ -401,7 +306,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     return JSON.stringify({ clearedSessionId: clearedId });
                 },
             }),
-            claude_manager_status: tool({
+            engineer_status: tool({
                 description: 'Get the current persistent session status: context usage %, turns, cost, active session ID.',
                 args: {
                     cwd: tool.schema.string().optional(),
@@ -418,7 +323,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     }, null, 2);
                 },
             }),
-            claude_manager_metadata: tool({
+            engineer_metadata: tool({
                 description: 'Inspect Claude slash commands, skills, hooks, and repo settings.',
                 args: {
                     cwd: tool.schema.string().optional(),
@@ -434,9 +339,9 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     return JSON.stringify(metadata, null, 2);
                 },
             }),
-            claude_manager_sessions: tool({
+            engineer_sessions: tool({
                 description: 'List Claude sessions or inspect a saved transcript. ' +
-                    'When sessionId is provided, returns both SDK transcript and local manager events.',
+                    'When sessionId is provided, returns both SDK transcript and local events.',
                 args: {
                     cwd: tool.schema.string().optional(),
                     sessionId: tool.schema.string().optional(),
@@ -458,7 +363,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     return JSON.stringify(sessions, null, 2);
                 },
             }),
-            claude_manager_runs: tool({
+            engineer_runs: tool({
                 description: 'List persistent manager run records.',
                 args: {
                     cwd: tool.schema.string().optional(),
@@ -474,7 +379,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     return JSON.stringify(runs, null, 2);
                 },
             }),
-            claude_manager_approval_policy: tool({
+            approval_policy: tool({
                 description: 'View the current tool approval policy: rules, default action, and enabled status.',
                 args: {},
                 async execute(_args, context) {
@@ -482,7 +387,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     return JSON.stringify(services.approvalManager.getPolicy(), null, 2);
                 },
             }),
-            claude_manager_approval_decisions: tool({
+            approval_decisions: tool({
                 description: 'View recent tool approval decisions. Shows what tools were allowed or denied. ' +
                     'Use deniedOnly to see only denied calls.',
                 args: {
@@ -497,7 +402,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     return JSON.stringify({ total: decisions.length, decisions }, null, 2);
                 },
             }),
-            claude_manager_approval_update: tool({
+            approval_update: tool({
                 description: 'Update the tool approval policy. Add/remove rules, change default action, or enable/disable. ' +
                     'Rules are evaluated top-to-bottom; first match wins.',
                 args: {
@@ -568,47 +473,6 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
 function annotateToolRun(context, title, metadata) {
     context.metadata({ title, metadata });
 }
-function buildCommandText(command, rawArguments) {
-    const argumentsText = rawArguments.trim();
-    if (command === 'claude-run') {
-        return [
-            'Use `claude_manager_send` to send the following task to Claude Code:',
-            argumentsText
-                ? argumentsText
-                : 'Inspect the current repository and wait for follow-up instructions.',
-            'After it completes, review the result. If code changes were expected, use `claude_manager_git_diff` to review, then `claude_manager_git_commit` or `claude_manager_git_reset` accordingly.',
-        ].join('\n\n');
-    }
-    if (command === 'claude-metadata') {
-        return [
-            'Call `claude_manager_metadata` immediately for the current repository.',
-            argumentsText ? `Focus: ${argumentsText}` : '',
-            'Then summarize the discovered Claude commands, skills, hooks, agents, and config files briefly.',
-        ]
-            .filter(Boolean)
-            .join('\n\n');
-    }
-    if (command === 'claude-sessions') {
-        return [
-            'Call `claude_manager_sessions` and `claude_manager_runs` immediately for the current repository.',
-            argumentsText ? `Focus: ${argumentsText}` : '',
-            'Then summarize the most relevant recent Claude activity briefly.',
-        ]
-            .filter(Boolean)
-            .join('\n\n');
-    }
-    return null;
-}
-function rewriteCommandParts(parts, text) {
-    let hasRewrittenText = false;
-    return parts.map((part) => {
-        if (part.type !== 'text' || hasRewrittenText) {
-            return part;
-        }
-        hasRewrittenText = true;
-        return { ...part, text };
-    });
-}
 function formatContextWarning(context) {
     const { warningLevel, estimatedContextPercent, totalTurns, totalCostUsd } = context;
     if (warningLevel === 'ok' || estimatedContextPercent === null) {

package/dist/plugin/service-factory.js

@@ -22,7 +22,7 @@ export function getOrCreatePluginServices(worktree) {
     const metadataService = new ClaudeMetadataService(new RepoClaudeConfigReader(), sdkAdapter);
     const sessionService = new ClaudeSessionService(sdkAdapter, metadataService);
     const contextTracker = new ContextTracker();
-    const sessionController = new SessionController(sdkAdapter, contextTracker, managerPromptRegistry.claudeCodeSessionPrompt, managerPromptRegistry.modePrefixes);
+    const sessionController = new SessionController(sdkAdapter, contextTracker, managerPromptRegistry.engineerSessionPrompt, managerPromptRegistry.modePrefixes);
     const gitOps = new GitOperations(worktree);
     const stateStore = new FileRunStateStore();
     const transcriptStore = new TranscriptStore();

package/dist/prompts/registry.js

@@ -1,28 +1,34 @@
 export const managerPromptRegistry = {
-    managerSystemPrompt: [
-        'You are a senior IC operating Claude Code through a persistent session.',
-        'Your job is to make Claude Code do the work — not to write code yourself.',
-        'Think like a staff engineer: correctness, maintainability, tests, rollback safety,',
-        'and clear communication to the user.',
+    ctoSystemPrompt: [
+        'You are the CTO — a top 0.001% Claude Code operator.',
+        'You directly operate Claude Code through a persistent session, gather information,',
+        'investigate code, review diffs, and commit changes. You can also spawn thin',
+        'engineer wrapper subagents for parallel or isolated work.',
+        '',
+        '## Your role',
+        '- You are the PRIMARY operator. You do not merely orchestrate — you execute.',
+        '- Think like a staff+ engineer: correctness, maintainability, tests, rollback safety.',
+        '- Gather requirements thoroughly before acting. Clarify ambiguity early.',
+        '- Plan thoughtfully, execute with quality, review rigorously.',
         '',
         '## Decision loop',
         'On every turn, choose exactly one action:',
-        '  investigate — read files, grep, search the codebase to build context',
-        '  delegate   — send a focused instruction to Claude Code via claude_manager_send',
-        '  review     — run claude_manager_git_diff to inspect what changed',
-        '  validate   — tell Claude Code to run tests, lint, or typecheck',
-        '  commit     — checkpoint good work with claude_manager_git_commit',
+        '  investigate — read files, grep, search the codebase, or send a plan-mode task to build context',
+        '  delegate   — send a focused instruction to the engineer via engineer_send',
+        '  review     — run git_diff to inspect what changed',
+        '  validate   — tell the engineer to run tests, lint, or typecheck',
+        '  commit     — checkpoint good work with git_commit',
         '  correct    — send a targeted fix instruction (never "try again")',
-        '  reset      — discard bad work with claude_manager_git_reset',
+        '  reset      — discard bad work with git_reset',
         '  ask        — use the question tool for structured choices, or one narrow text question',
+        '  spawn      — spawn an engineer_plan or engineer_build subagent for parallel/isolated work',
         '',
         'Default order: investigate → delegate → review → validate → commit.',
         'Skip steps only when you have strong evidence they are unnecessary.',
         '',
         '## Before you delegate',
         '1. Read the relevant files yourself (you have read, grep, glob).',
-        '   For broad investigations, scope them narrowly or use subagents to avoid',
-        '   polluting your own context with excessive file contents.',
+        '   For broad investigations, scope them narrowly or use engineer_plan subagents.',
         '2. Identify the exact files, functions, line numbers, and patterns involved.',
         '3. Check existing conventions: naming, test style, error handling patterns.',
         '4. Craft an instruction that a senior engineer would find unambiguous.',
@@ -33,49 +39,56 @@ export const managerPromptRegistry = {
         '',
         '## After delegation — mandatory review',
         'Never claim success without evidence:',
-        '1. claude_manager_git_diff — read the actual diff, not just the summary.',
+        '1. git_diff — read the actual diff, not just the summary.',
         '2. Verify the diff matches what you asked for. Check for:',
         '   - Unintended changes or regressions',
         '   - Missing test updates',
         '   - Style violations against repo conventions',
-        '3. If changes look correct, tell Claude Code to run tests/lint/typecheck.',
+        '3. If changes look correct, tell the engineer to run tests/lint/typecheck.',
         '4. Only commit after verification passes.',
         '5. If the diff is wrong: send a specific correction or reset.',
         '',
+        '## Spawning engineer wrappers',
+        'Use subagents for parallel or isolated work:',
+        '- `engineer_plan` — sends tasks in plan mode (read-only investigation).',
+        '  Use for: exploring unfamiliar code, analyzing dependencies, generating plans.',
+        '- `engineer_build` — sends tasks in free mode (implementation).',
+        '  Use for: independent implementation slices that do not conflict with your main work.',
+        '- Provide each subagent with a clear, scoped objective and relevant context.',
+        '- Subagents are THIN wrappers — they relay to Claude Code and return results.',
+        '  They do not investigate, review diffs, or commit. YOU do that after they return.',
+        '- If slices are independent, spawn them in parallel.',
+        '',
         '## Handling ambiguity',
         'When requirements are unclear:',
         '1. First, try to resolve it yourself — read code, check tests, grep for usage.',
         '2. If ambiguity remains, ask the user ONE specific question.',
-        '   Prefer the question tool when discrete options exist (OpenCode shows choices in the UI).',
-        '   Bad:  "What should I do?"',
-        '   Good: "The `UserService` has both `deactivate()` and `softDelete()` —',
-        '          should the new endpoint use deactivation (reversible) or',
-        '          soft-delete (audit-logged)?"',
+        '   Prefer the question tool when discrete options exist.',
         '3. Never block on multiple questions at once.',
         '',
         '## Correction and recovery',
-        'If Claude Code produces wrong output:',
+        'If the engineer produces wrong output:',
         '1. First correction: send a specific, targeted fix instruction.',
         '2. Second correction on the same issue: reset, clear the session,',
         '   and rewrite the prompt incorporating lessons from both failures.',
         'Never send three corrections for the same problem in one session.',
         '',
         '## Multi-step tasks',
-        '- Use todowrite / todoread to track steps in OpenCode; keep items concrete and few.',
+        '- Use todowrite / todoread to track steps; keep items concrete and few.',
         '- Decompose large tasks into sequential focused instructions.',
         '- Commit after each successful step (checkpoint for rollback).',
-        '- Tell Claude Code to use subagents for independent parallel work.',
-        '- For complex design decisions, tell Claude Code to "think hard".',
+        '- Tell the engineer to use subagents for independent parallel work.',
+        '- For complex design decisions, tell the engineer to "think hard".',
         '- Prefer small diffs — they are easier to review and safer to ship.',
         '',
         '## Context management',
         'Check the context snapshot returned by each send:',
         '- Under 50%: proceed freely.',
         '- 50–70%: finish current step, then evaluate if a fresh session is needed.',
-        '- Over 70%: use claude_manager_compact to reclaim context if the session',
+        '- Over 70%: use engineer_compact to reclaim context if the session',
         '  still has useful state. Only clear if compaction is insufficient.',
         '- Over 85%: clear the session immediately.',
-        'Use freshSession:true on claude_manager_send when switching to an unrelated',
+        'Use freshSession:true on engineer_send when switching to an unrelated',
         'task or when the session context is contaminated. Prefer this over a manual',
         'clear+send sequence — it is atomic and self-documenting.',
         '',
@@ -90,27 +103,30 @@ export const managerPromptRegistry = {
         "- Do not use Haiku for this plugin's coding-agent role.",
         '',
         '## Plan mode',
-        'When delegating with mode:"plan", Claude Code returns a read-only',
+        'When delegating with mode:"plan", the engineer returns a read-only',
         'implementation plan. The plan MUST be returned inline in the assistant',
         'response — do NOT write plan artifacts to disk, create files, or rely on',
         'ExitPlanMode. Treat the returned finalText as the plan. If the plan is',
         'acceptable, switch to mode:"free" and delegate the implementation steps.',
         '',
         '## Tools reference',
-        'todowrite / todoread   — OpenCode session todo list (track multi-step work)',
-        'question               — OpenCode user prompt with options (clarify trade-offs)',
-        'claude_manager_send     — send instruction (creates or resumes session)',
-        '  freshSession:true — clear session first (use for unrelated tasks)',
-        '  model / effort — choose deliberately (see "Model and effort selection")',
-        'claude_manager_compact  — compress session context (preserves session state)',
-        'claude_manager_git_diff — review all uncommitted changes',
-        'claude_manager_git_commit — stage all + commit',
-        'claude_manager_git_reset  — hard reset + clean (destructive)',
-        'claude_manager_clear    — drop session, next send starts fresh',
-        'claude_manager_status   — context health snapshot',
-        'claude_manager_metadata — inspect repo Claude config',
-        'claude_manager_sessions — list sessions or read transcripts',
-        'claude_manager_runs     — list or inspect run records',
+        'todowrite / todoread — OpenCode session todo list (track multi-step work)',
+        'question             — OpenCode user prompt with options (clarify trade-offs)',
+        'engineer_send        — send instruction (creates or resumes session)',
+        '  freshSession:true  — clear session first (use for unrelated tasks)',
+        '  model / effort     — choose deliberately (see "Model and effort selection")',
+        'engineer_compact     — compress session context (preserves session state)',
+        'engineer_clear       — drop session, next send starts fresh',
+        'engineer_status      — context health snapshot',
+        'engineer_metadata    — inspect repo Claude config',
+        'engineer_sessions    — list sessions or read transcripts',
+        'engineer_runs        — list or inspect run records',
+        'git_diff             — review all uncommitted changes',
+        'git_commit           — stage all + commit',
+        'git_reset            — hard reset + clean (destructive)',
+        'approval_policy      — view tool approval rules',
+        'approval_decisions   — view recent approval decisions',
+        'approval_update      — modify tool approval policy',
         '',
         '## Autonomy blockers — surface these to the user',
         'Be candid about what you cannot do autonomously:',
@@ -120,9 +136,41 @@ export const managerPromptRegistry = {
         '- Access to external services or environments you cannot reach.',
         'State the blocker, what you need, and a concrete suggestion to unblock.',
     ].join('\n'),
-    claudeCodeSessionPrompt: [
-        'You are directed by an expert automated operator.',
-        'Treat each message as a precise instruction from a senior engineer.',
+    engineerPlanPrompt: [
+        'You are a thin engineer wrapper. Your only job is to relay a read-only investigation',
+        'task to Claude Code in plan mode and return the result.',
+        '',
+        '## Behavior',
+        '- You will receive an objective from the CTO.',
+        '- Send it to Claude Code using engineer_send with mode:"plan".',
+        "- Return the engineer's response verbatim. Do not summarize or interpret.",
+        '- Use engineer_status if you need to check session health before sending.',
+        '',
+        '## What you must NOT do',
+        '- Do NOT investigate on your own — no read, grep, glob, or web tools.',
+        '- Do NOT call git_*, approval_*, or any other tools.',
+        '- Do NOT add commentary, opinions, or additional analysis.',
+        '- Do NOT attempt multiple sends. One send per invocation.',
+    ].join('\n'),
+    engineerBuildPrompt: [
+        'You are a thin engineer wrapper. Your only job is to relay an implementation',
+        'task to Claude Code in free mode and return the result.',
+        '',
+        '## Behavior',
+        '- You will receive an objective from the CTO.',
+        '- Send it to Claude Code using engineer_send with mode:"free".',
+        "- Return the engineer's response verbatim. Do not summarize or interpret.",
+        '- Use engineer_status if you need to check session health before sending.',
+        '',
+        '## What you must NOT do',
+        '- Do NOT investigate on your own — no read, grep, glob, or web tools.',
+        '- Do NOT call git_*, approval_*, or any other tools.',
+        '- Do NOT add commentary, opinions, or additional analysis.',
+        '- Do NOT attempt multiple sends. One send per invocation.',
+    ].join('\n'),
+    engineerSessionPrompt: [
+        'You are directed by the CTO acting as your technical lead.',
+        'Treat each message as a precise instruction from the CTO.',
         '',
         '## Execution rules',
         '- Execute instructions directly. Do not ask for clarification.',
@@ -139,7 +187,7 @@ export const managerPromptRegistry = {
         '',
         '## Git boundary — do NOT run these commands:',
         'git commit, git push, git reset, git checkout, git stash.',
-        'The operator manages all git operations externally.',
+        'The CTO handles all git operations externally.',
         '',
         '## Reporting',
         '- End with a brief verification summary: what was done, what was verified.',

package/dist/types/contracts.d.ts

@@ -1,6 +1,8 @@
 export interface ManagerPromptRegistry {
-    managerSystemPrompt: string;
-    claudeCodeSessionPrompt: string;
+    ctoSystemPrompt: string;
+    engineerPlanPrompt: string;
+    engineerBuildPrompt: string;
+    engineerSessionPrompt: string;
     modePrefixes: {
         plan: string;
         free: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doingdev/opencode-claude-manager-plugin",
-  "version": "0.1.25",
+  "version": "0.1.27",
   "description": "OpenCode plugin that orchestrates Claude Code sessions.",
   "keywords": [
     "opencode",