@doingdev/opencode-claude-manager-plugin 0.1.43 → 0.1.46

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, 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

@@ -83,10 +83,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

@@ -167,12 +167,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);
@@ -213,10 +213,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({
@@ -236,6 +238,22 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     return executeDelegate({ ...args, mode: 'plan', wrapperType: 'explore' }, context);
                 },
             }),
+            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) {
+                    return executeDelegate({ ...args, mode: 'free', wrapperType: 'engineer_verify' }, context);
+                },
+            }),
             implement: tool({
                 description: 'Implement code changes - can read, edit, and create files. ' +
                     'Use after exploration to make changes.',

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

@@ -162,7 +162,12 @@ export const managerPromptRegistry = {
         '- `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.',
+        '- `engineer_verify` — verification. Use for: running tests, lint, typecheck, build.',
+        '  Use after implementation to confirm correctness.',
+        '- You may run MULTIPLE `engineer_explore` agents in parallel for independent investigations.',
+        '- You may run MULTIPLE `engineer_verify` agents in parallel for independent verification tasks.',
+        '- Only run ONE `engineer_implement` agent at a time — it makes changes to the worktree.',
+        '- Coordinate so that only one implement/verify runs at a time to avoid git conflicts.',
         '',
         '## Context efficiency',
         '- Use `engineer_explore` for broad exploration so your own context stays clean.',
@@ -217,6 +222,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;
@@ -111,15 +112,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.46",
   "description": "OpenCode plugin that orchestrates Claude Code sessions.",
   "keywords": [
     "opencode",