@doingdev/opencode-claude-manager-plugin 0.1.42 → 0.1.44

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import type { Plugin } from '@opencode-ai/plugin';
 import { ClaudeManagerPlugin } from './plugin/claude-manager.plugin.js';
-export type { ClaudeCapabilitySnapshot, ClaudeSessionRunResult, ClaudeSessionSummary, ClaudeSessionTranscriptMessage, ManagerPromptRegistry, RunClaudeSessionInput, SessionContextSnapshot, GitDiffResult, GitOperationResult, PersistentRunRecord, PersistentRunResult, ActiveSessionState, ContextWarningLevel, SessionMode, LiveTailEvent, ToolOutputPreview, ToolApprovalRule, ToolApprovalPolicy, ToolApprovalDecision, } from './types/contracts.js';
+export type { ClaudeCapabilitySnapshot, ClaudeSessionRunResult, ClaudeSessionSummary, ClaudeSessionTranscriptMessage, ManagerPromptRegistry, RunClaudeSessionInput, SessionContextSnapshot, GitDiffResult, GitOperationResult, PersistentRunRecord, PersistentRunResult, AgentSlotType, RunningTask, SlotStatus, ManagerStatus, ContextWarningLevel, SessionMode, LiveTailEvent, ToolOutputPreview, ToolApprovalRule, ToolApprovalPolicy, ToolApprovalDecision, } from './types/contracts.js';
 export { SessionLiveTailer } from './claude/session-live-tailer.js';
 export { ClaudeManagerPlugin };
 export declare const plugin: Plugin;

package/dist/manager/persistent-manager.d.ts

@@ -1,4 +1,4 @@
-import type { ClaudeSessionEvent, ClaudeSessionRunResult, PersistentRunRecord, PersistentRunResult, SessionContextSnapshot, GitDiffResult, GitOperationResult } from '../types/contracts.js';
+import type { AgentSlotType, ClaudeSessionEvent, ClaudeSessionRunResult, GitDiffResult, GitOperationResult, ManagerStatus, PersistentRunRecord, PersistentRunResult, RunningTask, SessionContextSnapshot, SlotStatus } from '../types/contracts.js';
 import type { ClaudeSessionEventHandler } from '../claude/claude-agent-sdk-adapter.js';
 import type { FileRunStateStore } from '../state/file-run-state-store.js';
 import type { TranscriptStore } from '../state/transcript-store.js';
@@ -12,6 +12,10 @@ export declare class PersistentManager {
     private readonly stateStore;
     private readonly contextTracker;
     private readonly transcriptStore;
+    private static readonly slotCounts;
+    private static readonly slotWaiters;
+    private static readonly runningTaskList;
+    private static readonly SLOT_MAXIMA;
     constructor(sessionController: SessionController, gitOps: GitOperations, stateStore: FileRunStateStore, contextTracker: ContextTracker, transcriptStore: TranscriptStore);
     /**
      * Send a message to the persistent Claude Code session.
@@ -21,6 +25,7 @@ export declare class PersistentManager {
         model?: string;
         effort?: 'low' | 'medium' | 'high' | 'max';
         mode?: 'plan' | 'free';
+        sessionSystemPrompt?: string;
         abortSignal?: AbortSignal;
     }, onEvent?: ClaudeSessionEventHandler): Promise<{
         sessionId: string | undefined;
@@ -60,13 +65,29 @@ export declare class PersistentManager {
      */
     gitReset(): Promise<GitOperationResult>;
     /**
-     * Get current session status and context health.
+     * Get current session status, context health, and slot usage.
      */
-    getStatus(): SessionContextSnapshot;
+    getStatus(): ManagerStatus;
+    /**
+     * Acquire a concurrency slot. Blocks if at capacity (implement=1, verify=5, explore=unlimited).
+     */
+    acquireSlot(slotType: AgentSlotType, taskDescription?: string): Promise<void>;
+    /**
+     * Release a concurrency slot. Wakes the next waiter if any.
+     */
+    releaseSlot(slotType: AgentSlotType, taskDescription?: string): void;
+    /**
+     * Get current slot usage across all agent types.
+     */
+    getSlotStatus(): SlotStatus;
+    /**
+     * List all currently running tasks with their slot types.
+     */
+    listRunningTasks(): RunningTask[];
     /**
      * Clear the active session. Next send creates a fresh one.
      */
-    clearSession(cwd: string): Promise<string | null>;
+    clearSession(): Promise<string | null>;
     /**
      * Compact the current session to free context.
      */
@@ -82,10 +103,6 @@ export declare class PersistentManager {
     executeTask(cwd: string, task: string, options?: {
         model?: string;
     }, onProgress?: PersistentManagerProgressHandler): Promise<PersistentRunResult>;
-    /**
-     * Try to restore session state from disk on startup.
-     */
-    tryRestore(cwd: string): Promise<boolean>;
     listRuns(cwd: string): Promise<PersistentRunRecord[]>;
     getRun(cwd: string, runId: string): Promise<PersistentRunRecord | null>;
 }

package/dist/manager/persistent-manager.js

@@ -5,6 +5,19 @@ export class PersistentManager {
     stateStore;
     contextTracker;
     transcriptStore;
+    // --- Slot tracking (static — shared across all instances) ---
+    static slotCounts = new Map([
+        ['implement', 0],
+        ['verify', 0],
+        ['explore', 0],
+    ]);
+    static slotWaiters = new Map();
+    static runningTaskList = [];
+    static SLOT_MAXIMA = {
+        implement: 1,
+        verify: 5,
+        explore: Infinity,
+    };
     constructor(sessionController, gitOps, stateStore, contextTracker, transcriptStore) {
         this.sessionController = sessionController;
         this.gitOps = gitOps;
@@ -17,7 +30,7 @@ export class PersistentManager {
      * Creates a new session if none exists.
      */
     async sendMessage(cwd, message, options, onEvent) {
-        const result = await this.sessionController.sendMessage(cwd, message, options, onEvent);
+        const result = await this.sessionController.sendMessage(message, options, onEvent);
         if (result.sessionId && result.events.length > 0) {
             await this.transcriptStore.appendEvents(cwd, result.sessionId, result.events);
         }
@@ -63,22 +76,102 @@ export class PersistentManager {
         return this.gitOps.resetHard();
     }
     /**
-     * Get current session status and context health.
+     * Get current session status, context health, and slot usage.
      */
     getStatus() {
-        return this.sessionController.getContextSnapshot();
+        return {
+            context: this.sessionController.getContextSnapshot(),
+            slotStatus: this.getSlotStatus(),
+            runningTasks: this.listRunningTasks(),
+        };
+    }
+    /**
+     * Acquire a concurrency slot. Blocks if at capacity (implement=1, verify=5, explore=unlimited).
+     */
+    async acquireSlot(slotType, taskDescription) {
+        const max = PersistentManager.SLOT_MAXIMA[slotType];
+        const current = PersistentManager.slotCounts.get(slotType) ?? 0;
+        if (current < max) {
+            PersistentManager.slotCounts.set(slotType, current + 1);
+        }
+        else {
+            // At capacity — wait for a slot to be transferred by releaseSlot
+            await new Promise((resolve) => {
+                let waiters = PersistentManager.slotWaiters.get(slotType);
+                if (!waiters) {
+                    waiters = [];
+                    PersistentManager.slotWaiters.set(slotType, waiters);
+                }
+                waiters.push(resolve);
+            });
+            // Slot was transferred — count stays the same
+        }
+        if (taskDescription) {
+            PersistentManager.runningTaskList.push({
+                slotType,
+                task: taskDescription,
+                startedAt: new Date().toISOString(),
+            });
+        }
+    }
+    /**
+     * Release a concurrency slot. Wakes the next waiter if any.
+     */
+    releaseSlot(slotType, taskDescription) {
+        if (taskDescription) {
+            const idx = PersistentManager.runningTaskList.findIndex((t) => t.slotType === slotType && t.task === taskDescription);
+            if (idx !== -1) {
+                PersistentManager.runningTaskList.splice(idx, 1);
+            }
+        }
+        const waiters = PersistentManager.slotWaiters.get(slotType);
+        if (waiters && waiters.length > 0) {
+            // Transfer the slot directly to the next waiter (don't decrement count)
+            const next = waiters.shift();
+            next();
+        }
+        else {
+            const current = PersistentManager.slotCounts.get(slotType) ?? 0;
+            if (current > 0) {
+                PersistentManager.slotCounts.set(slotType, current - 1);
+            }
+        }
+    }
+    /**
+     * Get current slot usage across all agent types.
+     */
+    getSlotStatus() {
+        return {
+            implement: {
+                used: PersistentManager.slotCounts.get('implement') ?? 0,
+                max: PersistentManager.SLOT_MAXIMA.implement,
+            },
+            verify: {
+                used: PersistentManager.slotCounts.get('verify') ?? 0,
+                max: PersistentManager.SLOT_MAXIMA.verify,
+            },
+            explore: {
+                used: PersistentManager.slotCounts.get('explore') ?? 0,
+            },
+        };
+    }
+    /**
+     * List all currently running tasks with their slot types.
+     */
+    listRunningTasks() {
+        return [...PersistentManager.runningTaskList];
     }
     /**
      * Clear the active session. Next send creates a fresh one.
      */
-    async clearSession(cwd) {
-        return this.sessionController.clearSession(cwd);
+    async clearSession() {
+        return this.sessionController.clearSession();
     }
     /**
      * Compact the current session to free context.
      */
     async compactSession(cwd, onEvent) {
-        const result = await this.sessionController.compactSession(cwd, onEvent);
+        const result = await this.sessionController.compactSession(onEvent);
         if (result.sessionId && result.events.length > 0) {
             await this.transcriptStore.appendEvents(cwd, result.sessionId, result.events);
         }
@@ -120,7 +213,7 @@ export class PersistentManager {
         await this.stateStore.saveRun(runRecord);
         await onProgress?.(runRecord);
         try {
-            const result = await this.sessionController.sendMessage(cwd, task, options, async (event) => {
+            const result = await this.sessionController.sendMessage(task, options, async (event) => {
                 // Update run record with progress events
                 const currentRun = await this.stateStore.getRun(cwd, runId);
                 if (currentRun) {
@@ -167,12 +260,6 @@ export class PersistentManager {
             return { run: failedRun };
         }
     }
-    /**
-     * Try to restore session state from disk on startup.
-     */
-    async tryRestore(cwd) {
-        return this.sessionController.tryRestore(cwd);
-    }
     listRuns(cwd) {
         return this.stateStore.listRuns(cwd);
     }

package/dist/manager/session-controller.d.ts

@@ -5,9 +5,11 @@ export declare class SessionController {
     private readonly sdkAdapter;
     private readonly contextTracker;
     private readonly sessionPrompt;
+    private readonly wrapperType;
+    private readonly worktree;
     private readonly modePrefixes;
     private activeSessionId;
-    constructor(sdkAdapter: ClaudeAgentSdkAdapter, contextTracker: ContextTracker, sessionPrompt: string, modePrefixes?: {
+    constructor(sdkAdapter: ClaudeAgentSdkAdapter, contextTracker: ContextTracker, sessionPrompt: string | undefined, wrapperType: string, worktree: string, modePrefixes?: {
         plan: string;
         free: string;
     });
@@ -17,28 +19,23 @@ export declare class SessionController {
      * Send a message to the persistent session. Creates one if none exists.
      * Returns the session result including usage data.
      */
-    sendMessage(cwd: string, message: string, options?: {
+    sendMessage(message: string, options?: {
         model?: string;
         effort?: 'low' | 'medium' | 'high' | 'max';
         mode?: SessionMode;
+        sessionSystemPrompt?: string;
         abortSignal?: AbortSignal;
     }, onEvent?: ClaudeSessionEventHandler): Promise<ClaudeSessionRunResult>;
     /**
      * Send /compact to the current session to compress context.
      */
-    compactSession(cwd: string, onEvent?: ClaudeSessionEventHandler): Promise<ClaudeSessionRunResult>;
+    compactSession(onEvent?: ClaudeSessionEventHandler): Promise<ClaudeSessionRunResult>;
     /**
      * Clear the current session. The next sendMessage will create a fresh one.
      */
-    clearSession(cwd: string): Promise<string | null>;
+    clearSession(): Promise<string | null>;
     /**
      * Get current context tracking snapshot.
      */
     getContextSnapshot(): SessionContextSnapshot;
-    /**
-     * Try to restore active session from persisted state on startup.
-     */
-    tryRestore(cwd: string): Promise<boolean>;
-    private persistActiveSession;
-    private removeActiveSession;
 }

package/dist/manager/session-controller.js

@@ -1,19 +1,20 @@
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
-const ACTIVE_SESSION_FILE = '.claude-manager/active-session.json';
 export class SessionController {
     sdkAdapter;
     contextTracker;
     sessionPrompt;
+    wrapperType;
+    worktree;
     modePrefixes;
     activeSessionId = null;
-    constructor(sdkAdapter, contextTracker, sessionPrompt, modePrefixes = {
+    constructor(sdkAdapter, contextTracker, sessionPrompt, wrapperType, worktree, modePrefixes = {
         plan: '',
         free: '',
     }) {
         this.sdkAdapter = sdkAdapter;
         this.contextTracker = contextTracker;
         this.sessionPrompt = sessionPrompt;
+        this.wrapperType = wrapperType;
+        this.worktree = worktree;
         this.modePrefixes = modePrefixes;
     }
     get isActive() {
@@ -26,12 +27,12 @@ export class SessionController {
      * Send a message to the persistent session. Creates one if none exists.
      * Returns the session result including usage data.
      */
-    async sendMessage(cwd, message, options, onEvent) {
+    async sendMessage(message, options, onEvent) {
         const mode = options?.mode ?? 'free';
         const prefix = this.modePrefixes[mode];
         const prompt = prefix ? `${prefix}\n\n${message}` : message;
         const input = {
-            cwd,
+            cwd: this.worktree,
             prompt,
             persistSession: true,
             permissionMode: mode === 'plan' ? 'plan' : 'acceptEdits',
@@ -46,8 +47,8 @@ export class SessionController {
             input.resumeSessionId = this.activeSessionId;
         }
         else {
-            // New session — use the base session prompt (project context is in the wrapper)
-            input.systemPrompt = this.sessionPrompt;
+            // New session — prefer dynamically constructed prompt from wrapper, fall back to static default
+            input.systemPrompt = options?.sessionSystemPrompt ?? this.sessionPrompt;
             input.model ??= 'claude-opus-4-6';
             input.effort ??= 'high';
         }
@@ -65,29 +66,26 @@ export class SessionController {
             outputTokens: result.outputTokens,
             contextWindowSize: result.contextWindowSize,
         });
-        // Persist active session state
-        await this.persistActiveSession(cwd);
         return result;
     }
     /**
      * Send /compact to the current session to compress context.
      */
-    async compactSession(cwd, onEvent) {
+    async compactSession(onEvent) {
         if (!this.activeSessionId) {
             throw new Error('No active session to compact');
         }
-        const result = await this.sendMessage(cwd, '/compact', undefined, onEvent);
+        const result = await this.sendMessage('/compact', undefined, onEvent);
         this.contextTracker.recordCompaction();
         return result;
     }
     /**
      * Clear the current session. The next sendMessage will create a fresh one.
      */
-    async clearSession(cwd) {
+    async clearSession() {
         const clearedId = this.activeSessionId;
         this.activeSessionId = null;
         this.contextTracker.reset();
-        await this.removeActiveSession(cwd);
         return clearedId;
     }
     /**
@@ -96,52 +94,4 @@ export class SessionController {
     getContextSnapshot() {
         return this.contextTracker.snapshot();
     }
-    /**
-     * Try to restore active session from persisted state on startup.
-     */
-    async tryRestore(cwd) {
-        const filePath = join(cwd, ACTIVE_SESSION_FILE);
-        try {
-            const raw = await readFile(filePath, 'utf-8');
-            const state = JSON.parse(raw);
-            if (state.sessionId && state.cwd === cwd) {
-                this.activeSessionId = state.sessionId;
-                this.contextTracker.restore(state);
-                return true;
-            }
-        }
-        catch {
-            // File doesn't exist or is corrupt — start fresh
-        }
-        return false;
-    }
-    async persistActiveSession(cwd) {
-        if (!this.activeSessionId) {
-            return;
-        }
-        const snap = this.contextTracker.snapshot();
-        const state = {
-            sessionId: this.activeSessionId,
-            cwd,
-            startedAt: new Date().toISOString(),
-            totalTurns: snap.totalTurns,
-            totalCostUsd: snap.totalCostUsd,
-            estimatedContextPercent: snap.estimatedContextPercent,
-            contextWindowSize: snap.contextWindowSize,
-            latestInputTokens: snap.latestInputTokens,
-        };
-        const filePath = join(cwd, ACTIVE_SESSION_FILE);
-        await mkdir(dirname(filePath), { recursive: true });
-        await writeFile(filePath, JSON.stringify(state, null, 2));
-    }
-    async removeActiveSession(cwd) {
-        const filePath = join(cwd, ACTIVE_SESSION_FILE);
-        try {
-            const { unlink } = await import('node:fs/promises');
-            await unlink(filePath);
-        }
-        catch {
-            // File doesn't exist — that's fine
-        }
-    }
 }

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

@@ -1,17 +1,18 @@
 /**
  * Agent hierarchy configuration for the CTO + Engineer Wrapper architecture.
  *
- * CTO (cto)                      — pure orchestrator, spawns engineers, reviews diffs, commits
- * Engineer Plan (engineer_plan)   — manages a Claude Code session for read-only investigation
- * Engineer Build (engineer_build) — manages a Claude Code session for implementation
- * Claude Code session             — the underlying AI session (prompt only, no OpenCode agent)
+ * CTO (cto)                            — pure orchestrator, spawns engineers, reviews diffs, commits
+ * Engineer Explore (engineer_explore)   — manages a Claude Code session for read-only investigation
+ * Engineer Implement (engineer_implement) — manages a Claude Code session for implementation
+ * Claude Code session                   — the underlying AI session (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";
+export declare const AGENT_ENGINEER_EXPLORE = "engineer_explore";
+export declare const AGENT_ENGINEER_IMPLEMENT = "engineer_implement";
+export declare const AGENT_ENGINEER_VERIFY = "engineer_verify";
 /** All restricted tool IDs (union of all domain groups) */
-export declare const ALL_RESTRICTED_TOOL_IDS: readonly ["explore", "implement", "compact_context", "clear_session", "session_health", "list_transcripts", "list_history", "git_diff", "git_commit", "git_reset", "git_status", "git_log", "approval_policy", "approval_decisions", "approval_update"];
+export declare const ALL_RESTRICTED_TOOL_IDS: readonly ["explore", "implement", "verify", "compact_context", "clear_session", "session_health", "list_transcripts", "list_history", "git_diff", "git_commit", "git_reset", "git_status", "git_log", "approval_policy", "approval_decisions", "approval_update"];
 type ToolPermission = 'allow' | 'ask' | 'deny';
 type AgentPermission = {
     '*'?: ToolPermission;
@@ -41,14 +42,21 @@ export declare function buildCtoAgentConfig(prompts: ManagerPromptRegistry): {
     permission: AgentPermission;
     prompt: string;
 };
-export declare function buildEngineerPlanAgentConfig(prompts: ManagerPromptRegistry): {
+export declare function buildEngineerExploreAgentConfig(prompts: ManagerPromptRegistry): {
     description: string;
     mode: "subagent";
     color: string;
     permission: AgentPermission;
     prompt: string;
 };
-export declare function buildEngineerBuildAgentConfig(prompts: ManagerPromptRegistry): {
+export declare function buildEngineerImplementAgentConfig(prompts: ManagerPromptRegistry): {
+    description: string;
+    mode: "subagent";
+    color: string;
+    permission: AgentPermission;
+    prompt: string;
+};
+export declare function buildEngineerVerifyAgentConfig(prompts: ManagerPromptRegistry): {
     description: string;
     mode: "subagent";
     color: string;

package/dist/plugin/agent-hierarchy.js

@@ -1,17 +1,18 @@
 /**
  * Agent hierarchy configuration for the CTO + Engineer Wrapper architecture.
  *
- * CTO (cto)                      — pure orchestrator, spawns engineers, reviews diffs, commits
- * Engineer Plan (engineer_plan)   — manages a Claude Code session for read-only investigation
- * Engineer Build (engineer_build) — manages a Claude Code session for implementation
- * Claude Code session             — the underlying AI session (prompt only, no OpenCode agent)
+ * CTO (cto)                            — pure orchestrator, spawns engineers, reviews diffs, commits
+ * Engineer Explore (engineer_explore)   — manages a Claude Code session for read-only investigation
+ * Engineer Implement (engineer_implement) — manages a Claude Code session for implementation
+ * Claude Code session                   — the underlying AI session (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';
+export const AGENT_ENGINEER_EXPLORE = 'engineer_explore';
+export const AGENT_ENGINEER_IMPLEMENT = 'engineer_implement';
+export const AGENT_ENGINEER_VERIFY = 'engineer_verify';
 // ---------------------------------------------------------------------------
 // Tool IDs — grouped by domain
 // ---------------------------------------------------------------------------
@@ -24,11 +25,13 @@ const ENGINEER_SHARED_TOOL_IDS = [
     'list_history',
 ];
 /** All engineer tools — mode-locked sends + shared session tools */
-const ENGINEER_TOOL_IDS = ['explore', 'implement', ...ENGINEER_SHARED_TOOL_IDS];
-/** Tools for the engineer_plan wrapper (plan-mode send + shared) */
-const ENGINEER_PLAN_TOOL_IDS = ['explore', ...ENGINEER_SHARED_TOOL_IDS];
-/** Tools for the engineer_build wrapper (build-mode send + shared) */
-const ENGINEER_BUILD_TOOL_IDS = ['implement', ...ENGINEER_SHARED_TOOL_IDS];
+const ENGINEER_TOOL_IDS = ['explore', 'implement', 'verify', ...ENGINEER_SHARED_TOOL_IDS];
+/** Tools for the engineer_explore wrapper (explore-mode send + shared) */
+const ENGINEER_EXPLORE_TOOL_IDS = ['explore', ...ENGINEER_SHARED_TOOL_IDS];
+/** Tools for the engineer_implement wrapper (implement-mode send + shared) */
+const ENGINEER_IMPLEMENT_TOOL_IDS = ['implement', ...ENGINEER_SHARED_TOOL_IDS];
+/** Tools for the engineer_verify wrapper (verify-mode send + shared) */
+const ENGINEER_VERIFY_TOOL_IDS = ['verify', ...ENGINEER_SHARED_TOOL_IDS];
 /** Git tools — owned by CTO */
 const GIT_TOOL_IDS = ['git_diff', 'git_commit', 'git_reset', 'git_status', 'git_log'];
 /** Approval tools — owned by CTO */
@@ -77,19 +80,20 @@ function buildCtoPermissions() {
         ...allowed,
         task: {
             '*': 'deny',
-            [AGENT_ENGINEER_PLAN]: 'allow',
-            [AGENT_ENGINEER_BUILD]: 'allow',
+            [AGENT_ENGINEER_EXPLORE]: 'allow',
+            [AGENT_ENGINEER_IMPLEMENT]: 'allow',
+            [AGENT_ENGINEER_VERIFY]: 'allow',
         },
     };
 }
-/** Engineer plan wrapper: read-only investigation + explore + shared session tools. */
-function buildEngineerPlanPermissions() {
+/** Engineer explore wrapper: read-only investigation + explore + shared session tools. */
+function buildEngineerExplorePermissions() {
     const denied = {};
     for (const toolId of ALL_RESTRICTED_TOOL_IDS) {
         denied[toolId] = 'deny';
     }
     const allowed = {};
-    for (const toolId of ENGINEER_PLAN_TOOL_IDS) {
+    for (const toolId of ENGINEER_EXPLORE_TOOL_IDS) {
         allowed[toolId] = 'allow';
     }
     return {
@@ -99,14 +103,31 @@ function buildEngineerPlanPermissions() {
         ...allowed,
     };
 }
-/** Engineer build wrapper: read-only investigation + implement + shared session tools. */
-function buildEngineerBuildPermissions() {
+/** Engineer implement wrapper: read-only investigation + implement + shared session tools. */
+function buildEngineerImplementPermissions() {
     const denied = {};
     for (const toolId of ALL_RESTRICTED_TOOL_IDS) {
         denied[toolId] = 'deny';
     }
     const allowed = {};
-    for (const toolId of ENGINEER_BUILD_TOOL_IDS) {
+    for (const toolId of ENGINEER_IMPLEMENT_TOOL_IDS) {
+        allowed[toolId] = 'allow';
+    }
+    return {
+        '*': 'deny',
+        ...READONLY_TOOLS,
+        ...denied,
+        ...allowed,
+    };
+}
+/** Engineer verify wrapper: read-only + verify + restricted bash for test/lint/typecheck/build. */
+function buildEngineerVerifyPermissions() {
+    const denied = {};
+    for (const toolId of ALL_RESTRICTED_TOOL_IDS) {
+        denied[toolId] = 'deny';
+    }
+    const allowed = {};
+    for (const toolId of ENGINEER_VERIFY_TOOL_IDS) {
         allowed[toolId] = 'allow';
     }
     return {
@@ -128,22 +149,31 @@ export function buildCtoAgentConfig(prompts) {
         prompt: prompts.ctoSystemPrompt,
     };
 }
-export function buildEngineerPlanAgentConfig(prompts) {
+export function buildEngineerExploreAgentConfig(prompts) {
     return {
         description: 'Thin high-judgment wrapper that frames work quickly and dispatches to Claude Code in plan mode for read-only investigation.',
         mode: 'subagent',
         color: '#D97757',
-        permission: buildEngineerPlanPermissions(),
-        prompt: prompts.engineerPlanPrompt,
+        permission: buildEngineerExplorePermissions(),
+        prompt: prompts.engineerExplorePrompt,
     };
 }
-export function buildEngineerBuildAgentConfig(prompts) {
+export function buildEngineerImplementAgentConfig(prompts) {
     return {
         description: 'Thin high-judgment wrapper that frames work quickly and dispatches to Claude Code in free mode for implementation.',
         mode: 'subagent',
         color: '#D97757',
-        permission: buildEngineerBuildPermissions(),
-        prompt: prompts.engineerBuildPrompt,
+        permission: buildEngineerImplementPermissions(),
+        prompt: prompts.engineerImplementPrompt,
+    };
+}
+export function buildEngineerVerifyAgentConfig(prompts) {
+    return {
+        description: 'Thin high-judgment wrapper that runs verification commands (tests, lint, typecheck, build) and reports pass/fail.',
+        mode: 'subagent',
+        color: '#D97757',
+        permission: buildEngineerVerifyPermissions(),
+        prompt: prompts.engineerVerifyPrompt,
     };
 }
 // ---------------------------------------------------------------------------

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

@@ -1,16 +1,17 @@
 import { tool } from '@opencode-ai/plugin';
 import { composeWrapperPrompt, managerPromptRegistry } from '../prompts/registry.js';
 import { discoverProjectClaudeFiles } from '../util/project-context.js';
-import { AGENT_CTO, AGENT_ENGINEER_BUILD, AGENT_ENGINEER_PLAN, buildCtoAgentConfig, buildEngineerBuildAgentConfig, buildEngineerPlanAgentConfig, denyRestrictedToolsGlobally, } from './agent-hierarchy.js';
+import { AGENT_CTO, AGENT_ENGINEER_EXPLORE, AGENT_ENGINEER_IMPLEMENT, AGENT_ENGINEER_VERIFY, buildCtoAgentConfig, buildEngineerExploreAgentConfig, buildEngineerImplementAgentConfig, buildEngineerVerifyAgentConfig, denyRestrictedToolsGlobally, } from './agent-hierarchy.js';
 import { getOrCreatePluginServices } from './service-factory.js';
 export const ClaudeManagerPlugin = async ({ worktree }) => {
     const services = getOrCreatePluginServices(worktree);
     async function executeDelegate(args, context) {
-        const cwd = args.cwd ?? context.worktree;
+        const wrapperServices = getOrCreatePluginServices(context.worktree);
         if (args.freshSession) {
-            await services.manager.clearSession(cwd);
+            await wrapperServices.manager.clearSession();
         }
-        const hasActiveSession = services.manager.getStatus().sessionId !== null;
+        const managerStatus = wrapperServices.manager.getStatus();
+        const hasActiveSession = managerStatus.context.sessionId !== null;
         const promptPreview = args.message.length > 100 ? args.message.slice(0, 100) + '...' : args.message;
         context.metadata({
             title: hasActiveSession
@@ -18,16 +19,17 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                 : '⚡ Claude Code: Initializing...',
             metadata: {
                 status: 'running',
-                sessionId: services.manager.getStatus().sessionId,
+                sessionId: managerStatus.context.sessionId,
                 prompt: promptPreview,
             },
         });
         let turnsSoFar;
         let costSoFar;
-        const result = await services.manager.sendMessage(cwd, args.message, {
+        const result = await wrapperServices.manager.sendMessage(context.worktree, args.message, {
             model: args.model,
             effort: args.effort,
             mode: args.mode,
+            sessionSystemPrompt: args.sessionSystemPrompt,
             abortSignal: context.abort,
         }, (event) => {
             if (event.turns !== undefined) {
@@ -182,7 +184,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
         let toolOutputs = [];
         if (result.sessionId) {
             try {
-                toolOutputs = await services.liveTailer.getToolOutputPreview(result.sessionId, cwd, 3);
+                toolOutputs = await wrapperServices.liveTailer.getToolOutputPreview(result.sessionId, context.worktree, 3);
             }
             catch {
                 // Non-critical — the JSONL file may not exist yet.
@@ -210,12 +212,14 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
             const claudeFiles = await discoverProjectClaudeFiles(worktree);
             const derivedPrompts = {
                 ...managerPromptRegistry,
-                engineerPlanPrompt: composeWrapperPrompt(managerPromptRegistry.engineerPlanPrompt, claudeFiles),
-                engineerBuildPrompt: composeWrapperPrompt(managerPromptRegistry.engineerBuildPrompt, claudeFiles),
+                engineerExplorePrompt: composeWrapperPrompt(managerPromptRegistry.engineerExplorePrompt, claudeFiles),
+                engineerImplementPrompt: composeWrapperPrompt(managerPromptRegistry.engineerImplementPrompt, claudeFiles),
+                engineerVerifyPrompt: composeWrapperPrompt(managerPromptRegistry.engineerVerifyPrompt, claudeFiles),
             };
             config.agent[AGENT_CTO] ??= buildCtoAgentConfig(managerPromptRegistry);
-            config.agent[AGENT_ENGINEER_PLAN] ??= buildEngineerPlanAgentConfig(derivedPrompts);
-            config.agent[AGENT_ENGINEER_BUILD] ??= buildEngineerBuildAgentConfig(derivedPrompts);
+            config.agent[AGENT_ENGINEER_EXPLORE] ??= buildEngineerExploreAgentConfig(derivedPrompts);
+            config.agent[AGENT_ENGINEER_IMPLEMENT] ??= buildEngineerImplementAgentConfig(derivedPrompts);
+            config.agent[AGENT_ENGINEER_VERIFY] ??= buildEngineerVerifyAgentConfig(derivedPrompts);
         },
         tool: {
             explore: tool({
@@ -225,14 +229,44 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                 args: {
                     message: tool.schema.string().min(1),
                     model: tool.schema
-                        .enum(['claude-opus-4-6', 'claude-sonnet-4-6', 'claude-sonnet-4-5'])
+                        .enum(['claude-opus-4-6', 'claude-sonnet-4-6'])
                         .optional(),
-                    effort: tool.schema.enum(['low', 'medium', 'high', 'max']).default('high'),
+                    effort: tool.schema.enum(['medium', 'high', 'max']).default('high'),
                     freshSession: tool.schema.boolean().default(false),
-                    cwd: tool.schema.string().optional(),
+                    sessionSystemPrompt: tool.schema.string().optional(),
                 },
                 async execute(args, context) {
-                    return executeDelegate({ ...args, mode: 'plan' }, context);
+                    const taskDesc = args.message.length > 100 ? args.message.slice(0, 100) + '...' : args.message;
+                    await services.manager.acquireSlot('explore', taskDesc);
+                    try {
+                        return await executeDelegate({ ...args, mode: 'plan', wrapperType: 'explore' }, context);
+                    }
+                    finally {
+                        services.manager.releaseSlot('explore', taskDesc);
+                    }
+                },
+            }),
+            verify: tool({
+                description: 'Run verification commands (tests, lint, typecheck, build) and report pass/fail. ' +
+                    'Use after implementation to verify correctness.',
+                args: {
+                    message: tool.schema.string().min(1),
+                    model: tool.schema
+                        .enum(['claude-opus-4-6', 'claude-sonnet-4-6'])
+                        .optional(),
+                    effort: tool.schema.enum(['medium', 'high', 'max']).default('high'),
+                    freshSession: tool.schema.boolean().default(false),
+                    sessionSystemPrompt: tool.schema.string().optional(),
+                },
+                async execute(args, context) {
+                    const taskDesc = args.message.length > 100 ? args.message.slice(0, 100) + '...' : args.message;
+                    await services.manager.acquireSlot('verify', taskDesc);
+                    try {
+                        return await executeDelegate({ ...args, mode: 'free', wrapperType: 'engineer_verify' }, context);
+                    }
+                    finally {
+                        services.manager.releaseSlot('verify', taskDesc);
+                    }
                 },
             }),
             implement: tool({
@@ -241,32 +275,39 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                 args: {
                     message: tool.schema.string().min(1),
                     model: tool.schema
-                        .enum(['claude-opus-4-6', 'claude-sonnet-4-6', 'claude-sonnet-4-5'])
+                        .enum(['claude-opus-4-6', 'claude-sonnet-4-6'])
                         .optional(),
-                    effort: tool.schema.enum(['low', 'medium', 'high', 'max']).default('high'),
+                    effort: tool.schema.enum(['medium', 'high', 'max']).default('high'),
                     freshSession: tool.schema.boolean().default(false),
-                    cwd: tool.schema.string().optional(),
+                    sessionSystemPrompt: tool.schema.string().optional(),
                 },
                 async execute(args, context) {
-                    return executeDelegate({ ...args, mode: 'free' }, context);
+                    const taskDesc = args.message.length > 100 ? args.message.slice(0, 100) + '...' : args.message;
+                    await services.manager.acquireSlot('implement', taskDesc);
+                    try {
+                        return await executeDelegate({ ...args, mode: 'free', wrapperType: 'implement' }, context);
+                    }
+                    finally {
+                        services.manager.releaseSlot('implement', taskDesc);
+                    }
                 },
             }),
             compact_context: tool({
                 description: 'Compress session history to reclaim context window space. ' +
                     'Preserves state while reducing token usage.',
                 args: {
-                    cwd: tool.schema.string().optional(),
+                    wrapperType: tool.schema.string().optional(),
                 },
                 async execute(args, context) {
-                    const cwd = args.cwd ?? context.worktree;
+                    const wrapperServices = getOrCreatePluginServices(context.worktree);
                     annotateToolRun(context, 'Compacting session', {});
-                    const result = await services.manager.compactSession(cwd);
-                    const snap = services.manager.getStatus();
-                    const contextWarning = formatContextWarning(snap);
+                    const result = await wrapperServices.manager.compactSession(context.worktree);
+                    const snap = wrapperServices.manager.getStatus();
+                    const contextWarning = formatContextWarning(snap.context);
                     context.metadata({
                         title: contextWarning
-                            ? `⚠️ Claude Code: Compacted — context at ${snap.estimatedContextPercent}%`
-                            : `✅ Claude Code: Compacted (${snap.totalTurns} turns, $${(snap.totalCostUsd ?? 0).toFixed(4)})`,
+                            ? `⚠️ Claude Code: Compacted — context at ${snap.context.estimatedContextPercent}%`
+                            : `✅ Claude Code: Compacted (${snap.context.totalTurns} turns, $${(snap.context.totalCostUsd ?? 0).toFixed(4)})`,
                         metadata: {
                             status: contextWarning ? 'warning' : 'success',
                             sessionId: result.sessionId,
@@ -277,7 +318,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                         finalText: result.finalText,
                         turns: result.turns,
                         totalCostUsd: result.totalCostUsd,
-                        context: snap,
+                        context: snap.context,
                         contextWarning,
                     }, null, 2);
                 },
@@ -355,70 +396,73 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                 description: 'Clear the active session to start fresh. ' +
                     'Use when context is full or starting a new task.',
                 args: {
-                    cwd: tool.schema.string().optional(),
+                    wrapperType: tool.schema.string().optional(),
                     reason: tool.schema.string().optional(),
                 },
                 async execute(args, context) {
+                    const wrapperServices = getOrCreatePluginServices(context.worktree);
                     annotateToolRun(context, 'Clearing session', {
                         reason: args.reason,
                     });
-                    const clearedId = await services.manager.clearSession(args.cwd ?? context.worktree);
+                    const clearedId = await wrapperServices.manager.clearSession();
                     return JSON.stringify({ clearedSessionId: clearedId });
                 },
             }),
             session_health: tool({
                 description: 'Check session health metrics: context usage %, turn count, cost, and session ID.',
                 args: {
-                    cwd: tool.schema.string().optional(),
+                    wrapperType: tool.schema.string().optional(),
                 },
-                async execute(_args, context) {
+                async execute(args, context) {
+                    const wrapperServices = getOrCreatePluginServices(context.worktree);
                     annotateToolRun(context, 'Checking session status', {});
-                    const status = services.manager.getStatus();
+                    const status = wrapperServices.manager.getStatus();
                     return JSON.stringify({
                         ...status,
-                        transcriptFile: status.sessionId
-                            ? `.claude-manager/transcripts/${status.sessionId}.json`
+                        transcriptFile: status.context.sessionId
+                            ? `.claude-manager/transcripts/${status.context.sessionId}.json`
                             : null,
-                        contextWarning: formatContextWarning(status),
+                        contextWarning: formatContextWarning(status.context),
                     }, null, 2);
                 },
             }),
             list_transcripts: tool({
                 description: 'List available session transcripts or inspect a specific transcript by ID.',
                 args: {
-                    cwd: tool.schema.string().optional(),
+                    wrapperType: tool.schema.string().optional(),
                     sessionId: tool.schema.string().optional(),
                 },
                 async execute(args, context) {
+                    const wrapperServices = getOrCreatePluginServices(context.worktree);
                     annotateToolRun(context, 'Inspecting Claude session history', {});
-                    const cwd = args.cwd ?? context.worktree;
                     if (args.sessionId) {
                         const [sdkTranscript, localEvents] = await Promise.all([
-                            services.sessions.getTranscript(args.sessionId, cwd),
-                            services.manager.getTranscriptEvents(cwd, args.sessionId),
+                            wrapperServices.sessions.getTranscript(args.sessionId, context.worktree),
+                            wrapperServices.manager.getTranscriptEvents(context.worktree, args.sessionId),
                         ]);
                         return JSON.stringify({
                             sdkTranscript,
                             localEvents: localEvents.length > 0 ? localEvents : undefined,
                         }, null, 2);
                     }
-                    const sessions = await services.sessions.listSessions(cwd);
+                    const sessions = await wrapperServices.sessions.listSessions(context.worktree);
                     return JSON.stringify(sessions, null, 2);
                 },
             }),
             list_history: tool({
                 description: 'List persistent run records from the manager or inspect a specific run.',
                 args: {
-                    cwd: tool.schema.string().optional(),
+                    wrapperType: tool.schema.string().optional(),
                     runId: tool.schema.string().optional(),
                 },
                 async execute(args, context) {
+                    const wrapperServices = getOrCreatePluginServices(context.worktree);
                     annotateToolRun(context, 'Reading manager run state', {});
                     if (args.runId) {
-                        const run = await services.manager.getRun(args.cwd ?? context.worktree, args.runId);
+                        const run = await wrapperServices.manager.getRun(context.worktree, args.runId);
                         return JSON.stringify(run, null, 2);
                     }
-                    const runs = await services.manager.listRuns(args.cwd ?? context.worktree);
+                    const runs = await wrapperServices.manager.listRuns(context.worktree);
                     return JSON.stringify(runs, null, 2);
                 },
             }),

package/dist/plugin/service-factory.js

@@ -9,23 +9,17 @@ import { GitOperations } from '../manager/git-operations.js';
 import { SessionController } from '../manager/session-controller.js';
 import { PersistentManager } from '../manager/persistent-manager.js';
 import { managerPromptRegistry } from '../prompts/registry.js';
-const serviceCache = new Map();
 export function getOrCreatePluginServices(worktree) {
-    const cachedServices = serviceCache.get(worktree);
-    if (cachedServices) {
-        return cachedServices;
-    }
     const approvalManager = new ToolApprovalManager();
     const sdkAdapter = new ClaudeAgentSdkAdapter(undefined, approvalManager);
     const sessionService = new ClaudeSessionService(sdkAdapter);
     const contextTracker = new ContextTracker();
-    const sessionController = new SessionController(sdkAdapter, contextTracker, managerPromptRegistry.engineerSessionPrompt, managerPromptRegistry.modePrefixes);
+    const sessionController = new SessionController(sdkAdapter, contextTracker, undefined, // session prompt is now constructed dynamically by the wrapper
+    'default', worktree, managerPromptRegistry.modePrefixes);
     const gitOps = new GitOperations(worktree);
     const stateStore = new FileRunStateStore();
     const transcriptStore = new TranscriptStore();
     const manager = new PersistentManager(sessionController, gitOps, stateStore, contextTracker, transcriptStore);
-    // Try to restore active session state (fire and forget)
-    manager.tryRestore(worktree).catch(() => { });
     const liveTailer = new SessionLiveTailer();
     const services = {
         manager,
@@ -33,6 +27,5 @@ export function getOrCreatePluginServices(worktree) {
         approvalManager,
         liveTailer,
     };
-    serviceCache.set(worktree, services);
     return services;
 }

package/dist/prompts/registry.js

@@ -13,6 +13,66 @@ export function composeWrapperPrompt(basePrompt, claudeFiles) {
     const sections = claudeFiles.map((f) => `### ${f.relativePath}\n${f.content}`).join('\n\n');
     return `${basePrompt}\n\n## Project Claude Files\nThe following project-level instructions were discovered from the repository.\n\n${sections}`;
 }
+/**
+ * Build an engineer wrapper prompt from shared sections plus mode-specific overrides.
+ */
+function buildEngineerWrapperPrompt(opts) {
+    return [
+        `You are a staff engineer managing a Claude Code session for ${opts.purpose}.`,
+        'You are not a forwarding layer — interpret the task in repo context before delegating.',
+        '',
+        '## Staff-level framing',
+        '- Identify the real problem, not just the stated request.',
+        '- Look for missing architecture, ownership, or precedence issues before delegating.',
+        '- Rewrite weak or underspecified requests into precise prompts for the engineer.',
+        '- For medium+ tasks, determine: the actual problem, the cleanest architecture,',
+        '  and what needs clarification before work begins.',
+        '- Ask ONE clarification first if it materially improves architecture.',
+        '',
+        '## Repo-context investigation',
+        '- Use read/grep/glob sparingly — only for spot-checks to sharpen a delegation.',
+        '- Do NOT implement changes yourself — investigation only.',
+        '',
+        '## Behavior',
+        `- Send the objective to the engineer using ${opts.toolName}.`,
+        "- Return the engineer's response verbatim. Do not summarize.",
+        `- Use freshSession:true on ${opts.toolName} when the task is unrelated to prior work.`,
+        '',
+        '## Constructing the engineer session prompt',
+        `When you call \`${opts.toolName}\`, you MUST include a \`sessionSystemPrompt\` argument.`,
+        'This becomes the system prompt for the underlying Claude Code session.',
+        'Build it as a self-contained description that equips the engineer to execute precisely.',
+        '',
+        'Structure it as:',
+        `1. **Role**: "${opts.roleDescription}"`,
+        '2. **Project rules**: Extract only the rules from the Project Claude Files below that',
+        '   are relevant to this specific task. Synthesize — do not dump everything.',
+        '   Cite file paths when the source matters (e.g. "per packages/core/CLAUDE.md").',
+        '3. **Verification**: How to verify the work (tests, lint, typecheck, expected behavior).',
+        '',
+        'Keep it concise: 3-6 sentences for role + relevant rules + verification.',
+        'The task itself goes in `message`, not in `sessionSystemPrompt`.',
+        '',
+        '## Context management',
+        '- Check session_health before sending.',
+        '- Under 50%: proceed. Over 70%: compact_context. Over 85%: clear_session.',
+        '',
+        '## Model selection',
+        ...opts.modelDefaults,
+        '',
+        '## Using appended Project Claude Files',
+        '- Treat appended Project Claude Files as project guidance for the engineer.',
+        '- Extract only the rules relevant to the current task when constructing sessionSystemPrompt.',
+        '- Prefer guidance from more specific/nested paths over root-level guidance on conflict.',
+        '- Direct user instructions override Claude-file guidance.',
+        '- Keep delegated instructions tight; do not dump the full file corpus unless needed.',
+        '- Cite file paths (e.g. "per packages/core/CLAUDE.md") when the source matters.',
+        '',
+        '## What you must NOT do',
+        '- Do NOT call git_*, approval_*, or any non-engineer tools.',
+        '- Do NOT add commentary to the engineer response.',
+    ].join('\n');
+}
 export const managerPromptRegistry = {
     ctoSystemPrompt: [
         'You are a staff+ technical owner who uses Claude Code better than anyone.',
@@ -25,7 +85,7 @@ export const managerPromptRegistry = {
         '- Verifying a result after an engineer returns.',
         '- Resolving one high-leverage ambiguity before dispatching.',
         'If you need more than 2 direct read/grep/glob lookups, stop and delegate',
-        'the investigation to `engineer_plan` instead.',
+        'the investigation to `engineer_explore` instead.',
         '',
         '## Core principle: technical ownership',
         'You are not a ticket-taker. Before acting, look for:',
@@ -51,12 +111,12 @@ export const managerPromptRegistry = {
         '  2. What is underspecified or conflicting.',
         '  3. What the cleanest architecture is.',
         '  4. What should be clarified before proceeding.',
-        '  Prefer spawning `engineer_plan` for repo exploration rather than reading',
+        '  Prefer spawning `engineer_explore` for repo exploration rather than reading',
         '  code yourself. Use at most 1-2 spot-check reads to sharpen the delegation.',
         '  Then delegate with file paths, line numbers, patterns, and verification.',
         '',
         '**Complex tasks** (multi-file feature, large refactor):',
-        '  1. Spawn `engineer_plan` to explore the repo, map dependencies, and analyze impact.',
+        '  1. Spawn `engineer_explore` to explore the repo, map dependencies, and analyze impact.',
         '  2. If requirements are unclear, ask the user ONE high-leverage question —',
         '     only when it materially changes architecture, ownership, or destructive behavior.',
         '     Prefer the question tool when discrete options exist.',
@@ -92,20 +152,34 @@ export const managerPromptRegistry = {
         '   style violations.',
         '2. git_status — check what files changed (quick overview)',
         '3. git_log -n 5 — see recent commits (understand context)',
-        '4. If correct: spawn `engineer_build` to run tests/lint/typecheck.',
+        '4. If correct: spawn `engineer_implement` to run tests/lint/typecheck.',
         '5. If tests pass: git_commit to checkpoint.',
-        '6. If wrong: spawn `engineer_build` with a specific correction.',
+        '6. If wrong: spawn `engineer_implement` with a specific correction.',
         '   On second failure: git_reset and rewrite the prompt from scratch.',
         '   Never send three corrections for the same problem.',
         '',
-        '## Engineers (via the Task tool)',
-        '- `engineer_plan` — read-only investigation. Use for: exploring unfamiliar code,',
-        '  mapping dependencies, analyzing impact, asking "how does X work?"',
-        '- `engineer_build` — implementation. Use for: all code changes, test runs, fixes.',
-        '- If steps are independent, spawn multiple engineers in parallel.',
+        '## Agent parallelism rules (enforced by the system)',
+        '- `engineer_explore`: UNLIMITED — spawn as many as you want for independent investigations',
+        '- `engineer_verify`: up to 5 — run multiple verifications in parallel (tests, lint, etc.)',
+        '- `engineer_implement`: STRICTLY 1 — only one can run at a time',
+        '',
+        '## Smarter orchestration patterns',
+        "- For important decisions, send the SAME feature to 2-3 engineer_explore agents with different angles:",
+        '  "Explore approach A for feature X" vs "Explore approach B for feature X"',
+        '  Then compare the plans and pick the best, or combine the best of both.',
+        "- Use engineer_verify to run verification in parallel with other work — it's cheap and independent.",
+        '- Before committing, run engineer_verify on the changed files to catch issues early.',
+        '- When blocked on one engineer (waiting for implement), run other explorations in parallel.',
+        "- Check getStatus().slotStatus before spawning — know what's running and what's available.",
+        '',
+        '## Available parallel agents',
+        'You have access to:',
+        '- Multiple engineer_explore agents (unlimited, read-only, different angles)',
+        '- Multiple engineer_verify agents (up to 5, verification commands)',
+        '- One engineer_implement at a time (makes changes to worktree)',
         '',
         '## Context efficiency',
-        '- Use `engineer_plan` for broad exploration so your own context stays clean.',
+        '- Use `engineer_explore` for broad exploration so your own context stays clean.',
         '- When spawning engineers for unrelated tasks, tell them to use freshSession:true.',
         '- Keep delegations focused — one concern per engineer invocation.',
         '',
@@ -134,106 +208,52 @@ export const managerPromptRegistry = {
         '- Destructive actions on shared state (deploy, publish, force-push).',
         'State the blocker, what you need, and a concrete suggestion to unblock.',
     ].join('\n'),
-    engineerPlanPrompt: [
-        'You are a staff engineer managing a Claude Code session for read-only investigation.',
-        'You are not a forwarding layer — interpret the task in repo context before delegating.',
-        '',
-        '## Staff-level framing',
-        '- Identify the real problem, not just the stated request.',
-        '- Look for missing architecture, ownership, or precedence issues before delegating.',
-        '- Rewrite weak or underspecified requests into precise prompts for the engineer.',
-        '- For medium+ tasks, determine: the actual problem, the cleanest architecture,',
-        '  and what needs clarification before work begins.',
-        '- Ask ONE clarification first if it materially improves architecture.',
-        '',
-        '## Repo-context investigation',
-        '- Use read/grep/glob sparingly — only for spot-checks to sharpen a delegation.',
-        '- If more than 2 lookups are needed, send the investigation to the engineer.',
-        '- Do NOT implement changes yourself — investigation only.',
-        '',
-        '## Behavior',
-        '- Send the objective to the engineer using explore.',
-        "- Return the engineer's response verbatim. Do not summarize.",
-        '- Use freshSession:true on explore when the task is unrelated to prior work.',
-        '',
-        '## Context management',
-        '- Check session_health before sending.',
-        '- Under 50%: proceed. Over 70%: compact_context. Over 85%: clear_session.',
-        '',
-        '## Model selection',
-        '- claude-opus-4-6 + high: complex analysis (default).',
-        '- claude-sonnet-4-6: lighter analysis.',
-        '- effort "medium": simple lookups.',
-        '',
-        '## Using appended Project Claude Files',
-        '- Treat appended Project Claude Files as project guidance for the engineer.',
-        '- Extract only the rules relevant to the current task when delegating.',
-        '- Prefer guidance from more specific/nested paths over root-level guidance on conflict.',
-        '- Direct user instructions override Claude-file guidance.',
-        '- Keep delegated instructions tight; do not dump the full file corpus unless needed.',
-        '- Cite file paths (e.g. "per packages/core/CLAUDE.md") when the source matters.',
-        '',
-        '## What you must NOT do',
-        '- Do NOT call git_*, approval_*, or any non-engineer tools.',
-        '- Do NOT add commentary to the engineer response.',
-    ].join('\n'),
-    engineerBuildPrompt: [
-        'You are a staff engineer managing a Claude Code session for implementation.',
-        'You are not a forwarding layer — interpret the task in repo context before delegating.',
-        '',
-        '## Staff-level framing',
-        '- Identify the real problem, not just the stated request.',
-        '- Look for missing architecture, ownership, or precedence issues before delegating.',
-        '- Rewrite weak or underspecified requests into precise prompts for the engineer.',
-        '- For medium+ tasks, determine: the actual problem, the cleanest architecture,',
-        '  and what needs clarification before work begins.',
-        '- Ask ONE clarification first if it materially improves architecture.',
-        '',
-        '## Repo-context investigation',
-        '- Use read/grep/glob sparingly — only for spot-checks to sharpen a delegation.',
-        '- If more than 2 lookups are needed, send the investigation to the engineer.',
-        '- Do NOT implement changes yourself — investigation only.',
-        '',
-        '## Behavior',
-        '- Send the objective to the engineer using implement.',
-        "- Return the engineer's response verbatim. Do not summarize.",
-        '- Use freshSession:true on implement when the task is unrelated to prior work.',
-        '',
-        '## Context management',
-        '- Check session_health before sending.',
-        '- Under 50%: proceed. Over 70%: compact_context. Over 85%: clear_session.',
-        '',
-        '## Model selection',
-        '- claude-opus-4-6 + high: most coding tasks (default).',
-        '- claude-sonnet-4-6: simple renames, formatting, scaffolding.',
-        '- effort "max": complex refactors, subtle bugs, cross-cutting changes.',
-        '',
-        '## Using appended Project Claude Files',
-        '- Treat appended Project Claude Files as project guidance for the engineer.',
-        '- Extract only the rules relevant to the current task when delegating.',
-        '- Prefer guidance from more specific/nested paths over root-level guidance on conflict.',
-        '- Direct user instructions override Claude-file guidance.',
-        '- Keep delegated instructions tight; do not dump the full file corpus unless needed.',
-        '- Cite file paths (e.g. "per packages/core/CLAUDE.md") when the source matters.',
-        '',
-        '## What you must NOT do',
-        '- Do NOT call git_*, approval_*, or any non-engineer tools.',
-        '- Do NOT add commentary to the engineer response.',
-    ].join('\n'),
+    engineerExplorePrompt: buildEngineerWrapperPrompt({
+        purpose: 'read-only investigation',
+        toolName: 'explore',
+        roleDescription: 'You are an expert engineer performing read-only investigation. ' +
+            'Execute directly. No preamble. Follow existing repo conventions.',
+        modelDefaults: [
+            '- claude-opus-4-6 + high: complex analysis (default).',
+            '- claude-sonnet-4-6: lighter analysis.',
+            '- effort "medium": simple lookups.',
+        ],
+    }),
+    engineerImplementPrompt: buildEngineerWrapperPrompt({
+        purpose: 'implementation',
+        toolName: 'implement',
+        roleDescription: 'You are an expert engineer implementing changes. ' +
+            'Execute directly. No preamble. Follow existing repo conventions. ' +
+            'Do not run git commit, git push, git reset, git checkout, or git stash — git operations are handled externally.',
+        modelDefaults: [
+            '- claude-opus-4-6 + high: most coding tasks (default).',
+            '- claude-sonnet-4-6: simple renames, formatting, scaffolding.',
+            '- effort "max": complex refactors, subtle bugs, cross-cutting changes.',
+        ],
+    }),
+    engineerVerifyPrompt: buildEngineerWrapperPrompt({
+        purpose: 'verification',
+        toolName: 'verify',
+        roleDescription: 'You are an expert engineer verifying changes. ' +
+            'Execute directly. No preamble. Follow existing repo conventions. ' +
+            'Do not run git commit, git push, git reset, git checkout, or git stash — git operations are handled externally.',
+        modelDefaults: [
+            '- claude-opus-4-6 + high: most verification tasks (default).',
+            '- claude-sonnet-4-6: simple test runs, lint checks.',
+            '- effort "medium": straightforward verification.',
+        ],
+    }),
     engineerSessionPrompt: [
         'You are an expert engineer. Execute instructions precisely.',
         '',
         '## Rules',
         '- Execute directly. No preamble, no restating the task.',
-        '- Prefer targeted file reads over reading entire files.',
-        '- Use subagents for independent parallel work.',
-        '- Follow existing repo conventions (naming, style, patterns).',
+        '- Follow existing repo conventions.',
+        '- Report exact output on failure.',
         '',
         '## Verification',
         '- Always verify your own work before reporting done.',
-        '- Run tests, lint, or typecheck when the instruction says to.',
         '- If no verification was specified, still run relevant tests if they exist.',
-        '- Report exact output on failure.',
         '',
         '## Git boundary — do NOT run:',
         'git commit, git push, git reset, git checkout, git stash.',
@@ -241,8 +261,7 @@ export const managerPromptRegistry = {
         '',
         '## Reporting',
         '- End with: what was done, what was verified, what passed/failed.',
-        '- Report blockers immediately with specifics: file, line, error.',
-        '- If partially complete, state exactly what remains.',
+        '- Report blockers immediately with specifics.',
     ].join('\n'),
     modePrefixes: {
         plan: [

package/dist/types/contracts.d.ts

@@ -1,7 +1,8 @@
 export interface ManagerPromptRegistry {
     ctoSystemPrompt: string;
-    engineerPlanPrompt: string;
-    engineerBuildPrompt: string;
+    engineerExplorePrompt: string;
+    engineerImplementPrompt: string;
+    engineerVerifyPrompt: string;
     engineerSessionPrompt: string;
     modePrefixes: {
         plan: string;
@@ -97,6 +98,30 @@ export interface SessionContextSnapshot {
     warningLevel: ContextWarningLevel;
     compactionCount: number;
 }
+export type AgentSlotType = 'implement' | 'verify' | 'explore';
+export interface RunningTask {
+    slotType: AgentSlotType;
+    task: string;
+    startedAt: string;
+}
+export interface SlotStatus {
+    implement: {
+        used: number;
+        max: number;
+    };
+    verify: {
+        used: number;
+        max: number;
+    };
+    explore: {
+        used: number;
+    };
+}
+export interface ManagerStatus {
+    context: SessionContextSnapshot;
+    slotStatus: SlotStatus;
+    runningTasks: RunningTask[];
+}
 export interface GitDiffResult {
     hasDiff: boolean;
     diffText: string;
@@ -111,16 +136,6 @@ export interface GitOperationResult {
     output: string;
     error?: string;
 }
-export interface ActiveSessionState {
-    sessionId: string;
-    cwd: string;
-    startedAt: string;
-    totalTurns: number;
-    totalCostUsd: number;
-    estimatedContextPercent: number | null;
-    contextWindowSize: number | null;
-    latestInputTokens: number | null;
-}
 export type PersistentRunStatus = 'running' | 'completed' | 'failed';
 export interface PersistentRunMessageRecord {
     timestamp: string;

package/package.json

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