@doingdev/opencode-claude-manager-plugin 0.1.43 → 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.
@@ -61,9 +65,25 @@ 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.
      */
@@ -83,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(): 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;
@@ -63,10 +76,90 @@ 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.
@@ -167,12 +260,6 @@ export class PersistentManager {
             return { run: failedRun };
         }
     }
-    /**
-     * Try to restore session state from disk on startup.
-     */
-    async tryRestore() {
-        return this.sessionController.tryRestore();
-    }
     listRuns(cwd) {
         return this.stateStore.listRuns(cwd);
     }

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

@@ -38,10 +38,4 @@ export declare class SessionController {
      * Get current context tracking snapshot.
      */
     getContextSnapshot(): SessionContextSnapshot;
-    /**
-     * Try to restore active session from persisted state on startup.
-     */
-    tryRestore(): Promise<boolean>;
-    private persistActiveSession;
-    private removeActiveSession;
 }

package/dist/manager/session-controller.js

@@ -1,8 +1,3 @@
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import { dirname } from 'node:path';
-function activeSessionFile(_wrapperType) {
-    return `.claude-manager/active-session.json`;
-}
 export class SessionController {
     sdkAdapter;
     contextTracker;
@@ -71,8 +66,6 @@ export class SessionController {
             outputTokens: result.outputTokens,
             contextWindowSize: result.contextWindowSize,
         });
-        // Persist active session state
-        await this.persistActiveSession();
         return result;
     }
     /**
@@ -93,7 +86,6 @@ export class SessionController {
         const clearedId = this.activeSessionId;
         this.activeSessionId = null;
         this.contextTracker.reset();
-        await this.removeActiveSession();
         return clearedId;
     }
     /**
@@ -102,51 +94,4 @@ export class SessionController {
     getContextSnapshot() {
         return this.contextTracker.snapshot();
     }
-    /**
-     * Try to restore active session from persisted state on startup.
-     */
-    async tryRestore() {
-        const filePath = activeSessionFile(this.wrapperType);
-        try {
-            const raw = await readFile(filePath, 'utf-8');
-            const state = JSON.parse(raw);
-            if (state.sessionId) {
-                this.activeSessionId = state.sessionId;
-                this.contextTracker.restore(state);
-                return true;
-            }
-        }
-        catch {
-            // File doesn't exist or is corrupt — start fresh
-        }
-        return false;
-    }
-    async persistActiveSession() {
-        if (!this.activeSessionId) {
-            return;
-        }
-        const snap = this.contextTracker.snapshot();
-        const state = {
-            sessionId: this.activeSessionId,
-            startedAt: new Date().toISOString(),
-            totalTurns: snap.totalTurns,
-            totalCostUsd: snap.totalCostUsd,
-            estimatedContextPercent: snap.estimatedContextPercent,
-            contextWindowSize: snap.contextWindowSize,
-            latestInputTokens: snap.latestInputTokens,
-        };
-        const filePath = activeSessionFile(this.wrapperType);
-        await mkdir(dirname(filePath), { recursive: true });
-        await writeFile(filePath, JSON.stringify(state, null, 2));
-    }
-    async removeActiveSession() {
-        const filePath = activeSessionFile(this.wrapperType);
-        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

@@ -10,8 +10,9 @@ import type { ManagerPromptRegistry } from '../types/contracts.js';
 export declare const AGENT_CTO = "cto";
 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;
@@ -55,6 +56,13 @@ export declare function buildEngineerImplementAgentConfig(prompts: ManagerPrompt
     permission: AgentPermission;
     prompt: string;
 };
+export declare function buildEngineerVerifyAgentConfig(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

@@ -12,6 +12,7 @@
 export const AGENT_CTO = 'cto';
 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];
+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 */
@@ -79,6 +82,7 @@ function buildCtoPermissions() {
             '*': 'deny',
             [AGENT_ENGINEER_EXPLORE]: 'allow',
             [AGENT_ENGINEER_IMPLEMENT]: 'allow',
+            [AGENT_ENGINEER_VERIFY]: 'allow',
         },
     };
 }
@@ -116,6 +120,23 @@ function buildEngineerImplementPermissions() {
         ...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 {
+        '*': 'deny',
+        ...READONLY_TOOLS,
+        ...denied,
+        ...allowed,
+    };
+}
 // ---------------------------------------------------------------------------
 // Agent config builders
 // ---------------------------------------------------------------------------
@@ -146,6 +167,15 @@ export function buildEngineerImplementAgentConfig(prompts) {
         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,
+    };
+}
 // ---------------------------------------------------------------------------
 // Global permission helper
 // ---------------------------------------------------------------------------

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

@@ -1,7 +1,7 @@
 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_EXPLORE, AGENT_ENGINEER_IMPLEMENT, buildCtoAgentConfig, buildEngineerExploreAgentConfig, buildEngineerImplementAgentConfig, 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);
@@ -10,7 +10,8 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
         if (args.freshSession) {
             await wrapperServices.manager.clearSession();
         }
-        const hasActiveSession = wrapperServices.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,7 +19,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                 : '⚡ Claude Code: Initializing...',
             metadata: {
                 status: 'running',
-                sessionId: wrapperServices.manager.getStatus().sessionId,
+                sessionId: managerStatus.context.sessionId,
                 prompt: promptPreview,
             },
         });
@@ -213,10 +214,12 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                 ...managerPromptRegistry,
                 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_EXPLORE] ??= buildEngineerExploreAgentConfig(derivedPrompts);
             config.agent[AGENT_ENGINEER_IMPLEMENT] ??= buildEngineerImplementAgentConfig(derivedPrompts);
+            config.agent[AGENT_ENGINEER_VERIFY] ??= buildEngineerVerifyAgentConfig(derivedPrompts);
         },
         tool: {
             explore: tool({
@@ -233,7 +236,37 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     sessionSystemPrompt: tool.schema.string().optional(),
                 },
                 async execute(args, context) {
-                    return executeDelegate({ ...args, mode: 'plan', wrapperType: 'explore' }, 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({
@@ -249,7 +282,14 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     sessionSystemPrompt: tool.schema.string().optional(),
                 },
                 async execute(args, context) {
-                    return executeDelegate({ ...args, mode: 'free', wrapperType: 'implement' }, 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({
@@ -263,11 +303,11 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     annotateToolRun(context, 'Compacting session', {});
                     const result = await wrapperServices.manager.compactSession(context.worktree);
                     const snap = wrapperServices.manager.getStatus();
-                    const contextWarning = formatContextWarning(snap);
+                    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,
@@ -278,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);
                 },
@@ -379,10 +419,10 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     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);
                 },
             }),

package/dist/plugin/service-factory.js

@@ -20,8 +20,6 @@ export function getOrCreatePluginServices(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().catch(() => { });
     const liveTailer = new SessionLiveTailer();
     const services = {
         manager,

package/dist/prompts/registry.js

@@ -158,11 +158,25 @@ export const managerPromptRegistry = {
         '   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_explore` — read-only investigation. Use for: exploring unfamiliar code,',
-        '  mapping dependencies, analyzing impact, asking "how does X work?"',
-        '- `engineer_implement` — 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_explore` for broad exploration so your own context stays clean.',
@@ -217,6 +231,18 @@ export const managerPromptRegistry = {
             '- 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.',
         '',

package/dist/types/contracts.d.ts

@@ -2,6 +2,7 @@ export interface ManagerPromptRegistry {
     ctoSystemPrompt: 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,15 +136,6 @@ export interface GitOperationResult {
     output: string;
     error?: string;
 }
-export interface ActiveSessionState {
-    sessionId: 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.43",
+  "version": "0.1.44",
   "description": "OpenCode plugin that orchestrates Claude Code sessions.",
   "keywords": [
     "opencode",