@doingdev/opencode-claude-manager-plugin 0.1.22 → 0.1.26

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

@@ -0,0 +1,490 @@
+import { tool } from '@opencode-ai/plugin';
+import { managerPromptRegistry } from '../prompts/registry.js';
+import { AGENT_CTO, AGENT_MANAGER, buildCtoAgentConfig, buildManagerAgentConfig, denyRestrictedToolsGlobally, } from './agent-hierarchy.js';
+import { getOrCreatePluginServices } from './service-factory.js';
+export const ClaudeManagerPlugin = async ({ worktree }) => {
+    const services = getOrCreatePluginServices(worktree);
+    return {
+        config: async (config) => {
+            config.agent ??= {};
+            config.permission ??= {};
+            denyRestrictedToolsGlobally(config.permission);
+            config.agent[AGENT_CTO] ??= buildCtoAgentConfig(managerPromptRegistry);
+            config.agent[AGENT_MANAGER] ??= buildManagerAgentConfig(managerPromptRegistry);
+        },
+        tool: {
+            engineer_send: tool({
+                description: 'Send a message to the persistent Claude Code session. ' +
+                    'Auto-creates a session on first call. Resumes the existing session on subsequent calls. ' +
+                    'Returns the assistant response and current context health snapshot. ' +
+                    'Use mode "plan" for read-only investigation and planning (no edits), ' +
+                    'or "free" (default) for normal execution with edit permissions. ' +
+                    'Set freshSession to clear the active session before sending (use for unrelated tasks). ' +
+                    'Prefer claude-opus-4-6 (default) for most coding work; use a Sonnet model for faster/lighter tasks. ' +
+                    'Prefer effort "high" (default) for most work; use "medium" for lighter tasks and "max" for especially hard problems.',
+                args: {
+                    message: tool.schema.string().min(1),
+                    model: tool.schema
+                        .enum(['claude-opus-4-6', 'claude-sonnet-4-6', 'claude-sonnet-4-5'])
+                        .optional(),
+                    effort: tool.schema
+                        .enum(['low', 'medium', 'high', 'max'])
+                        .default('high'),
+                    mode: tool.schema.enum(['plan', 'free']).default('free'),
+                    freshSession: tool.schema.boolean().default(false),
+                    cwd: tool.schema.string().optional(),
+                },
+                async execute(args, context) {
+                    const cwd = args.cwd ?? context.worktree;
+                    if (args.freshSession) {
+                        await services.manager.clearSession(cwd);
+                    }
+                    const hasActiveSession = services.manager.getStatus().sessionId !== null;
+                    const promptPreview = args.message.length > 100
+                        ? args.message.slice(0, 100) + '...'
+                        : args.message;
+                    context.metadata({
+                        title: hasActiveSession
+                            ? 'Claude Code: Resuming session...'
+                            : 'Claude Code: Initializing...',
+                        metadata: {
+                            sessionId: services.manager.getStatus().sessionId,
+                            prompt: promptPreview,
+                        },
+                    });
+                    let turnsSoFar = 0;
+                    let costSoFar = 0;
+                    const result = await services.manager.sendMessage(cwd, args.message, {
+                        model: args.model,
+                        effort: args.effort,
+                        mode: args.mode,
+                        abortSignal: context.abort,
+                    }, (event) => {
+                        if (event.turns !== undefined) {
+                            turnsSoFar = event.turns;
+                        }
+                        if (event.totalCostUsd !== undefined) {
+                            costSoFar = event.totalCostUsd;
+                        }
+                        const costLabel = `$${costSoFar.toFixed(4)}`;
+                        if (event.type === 'tool_call') {
+                            let toolName = 'tool';
+                            let inputPreview = '';
+                            try {
+                                const parsed = JSON.parse(event.text);
+                                toolName = parsed.name ?? 'tool';
+                                if (parsed.input) {
+                                    const inputStr = typeof parsed.input === 'string'
+                                        ? parsed.input
+                                        : JSON.stringify(parsed.input);
+                                    inputPreview =
+                                        inputStr.length > 150
+                                            ? inputStr.slice(0, 150) + '...'
+                                            : inputStr;
+                                }
+                            }
+                            catch {
+                                // ignore parse errors
+                            }
+                            context.metadata({
+                                title: `Claude Code: Running ${toolName}... (${turnsSoFar} turns, ${costLabel})`,
+                                metadata: {
+                                    sessionId: event.sessionId,
+                                    type: event.type,
+                                    tool: toolName,
+                                    input: inputPreview,
+                                },
+                            });
+                        }
+                        else if (event.type === 'assistant') {
+                            const thinkingPreview = event.text.length > 150
+                                ? event.text.slice(0, 150) + '...'
+                                : event.text;
+                            context.metadata({
+                                title: `Claude Code: Thinking... (${turnsSoFar} turns, ${costLabel})`,
+                                metadata: {
+                                    sessionId: event.sessionId,
+                                    type: event.type,
+                                    thinking: thinkingPreview,
+                                },
+                            });
+                        }
+                        else if (event.type === 'init') {
+                            context.metadata({
+                                title: `Claude Code: Session started`,
+                                metadata: {
+                                    sessionId: event.sessionId,
+                                    prompt: promptPreview,
+                                },
+                            });
+                        }
+                        else if (event.type === 'user') {
+                            const preview = event.text.length > 200
+                                ? event.text.slice(0, 200) + '...'
+                                : event.text;
+                            context.metadata({
+                                title: `Claude Code: Tool result (${turnsSoFar} turns, ${costLabel})`,
+                                metadata: {
+                                    sessionId: event.sessionId,
+                                    type: event.type,
+                                    output: preview,
+                                },
+                            });
+                        }
+                        else if (event.type === 'tool_progress') {
+                            let toolName = 'tool';
+                            let elapsed = 0;
+                            try {
+                                const parsed = JSON.parse(event.text);
+                                toolName = parsed.name ?? 'tool';
+                                elapsed = parsed.elapsed ?? 0;
+                            }
+                            catch {
+                                // ignore
+                            }
+                            context.metadata({
+                                title: `Claude Code: ${toolName} running ${elapsed > 0 ? `(${elapsed.toFixed(0)}s)` : ''}... (${turnsSoFar} turns, ${costLabel})`,
+                                metadata: {
+                                    sessionId: event.sessionId,
+                                    type: event.type,
+                                    tool: toolName,
+                                    elapsed,
+                                },
+                            });
+                        }
+                        else if (event.type === 'tool_summary') {
+                            const summary = event.text.length > 200
+                                ? event.text.slice(0, 200) + '...'
+                                : event.text;
+                            context.metadata({
+                                title: `Claude Code: Tool done (${turnsSoFar} turns, ${costLabel})`,
+                                metadata: {
+                                    sessionId: event.sessionId,
+                                    type: event.type,
+                                    summary,
+                                },
+                            });
+                        }
+                        else if (event.type === 'partial') {
+                            const delta = event.text.length > 200
+                                ? event.text.slice(0, 200) + '...'
+                                : event.text;
+                            context.metadata({
+                                title: `Claude Code: Writing... (${turnsSoFar} turns, ${costLabel})`,
+                                metadata: {
+                                    sessionId: event.sessionId,
+                                    type: event.type,
+                                    delta,
+                                },
+                            });
+                        }
+                        else if (event.type === 'error') {
+                            context.metadata({
+                                title: `Claude Code: Error`,
+                                metadata: {
+                                    sessionId: event.sessionId,
+                                    error: event.text.slice(0, 200),
+                                },
+                            });
+                        }
+                    });
+                    const costLabel = `$${(result.totalCostUsd ?? 0).toFixed(4)}`;
+                    const turns = result.turns ?? 0;
+                    const contextWarning = formatContextWarning(result.context);
+                    if (contextWarning) {
+                        context.metadata({
+                            title: `Claude Code: Context at ${result.context.estimatedContextPercent}% (${turns} turns)`,
+                            metadata: { sessionId: result.sessionId, contextWarning },
+                        });
+                    }
+                    else {
+                        context.metadata({
+                            title: `Claude Code: Complete (${turns} turns, ${costLabel})`,
+                            metadata: { sessionId: result.sessionId },
+                        });
+                    }
+                    // Fetch recent tool output from the JSONL file for richer feedback.
+                    let toolOutputs = [];
+                    if (result.sessionId) {
+                        try {
+                            toolOutputs = await services.liveTailer.getToolOutputPreview(result.sessionId, cwd, 3);
+                        }
+                        catch {
+                            // Non-critical — the JSONL file may not exist yet.
+                        }
+                    }
+                    return JSON.stringify({
+                        sessionId: result.sessionId,
+                        finalText: result.finalText,
+                        turns: result.turns,
+                        totalCostUsd: result.totalCostUsd,
+                        context: result.context,
+                        contextWarning,
+                        toolOutputs: toolOutputs.length > 0 ? toolOutputs : undefined,
+                    }, null, 2);
+                },
+            }),
+            engineer_compact: tool({
+                description: 'Compact the active Claude Code session to reclaim context space. ' +
+                    'Sends /compact to the session, which compresses prior conversation while preserving state. ' +
+                    'Use before clearing when context is high but the session still has useful state. ' +
+                    'Fails if there is no active session.',
+                args: {
+                    cwd: tool.schema.string().optional(),
+                },
+                async execute(args, context) {
+                    const cwd = args.cwd ?? context.worktree;
+                    annotateToolRun(context, 'Compacting session', {});
+                    const result = await services.manager.compactSession(cwd);
+                    const snap = services.manager.getStatus();
+                    const contextWarning = formatContextWarning(snap);
+                    context.metadata({
+                        title: contextWarning
+                            ? `Claude Code: Compacted — context at ${snap.estimatedContextPercent}%`
+                            : `Claude Code: Compacted (${snap.totalTurns} turns, $${(snap.totalCostUsd ?? 0).toFixed(4)})`,
+                        metadata: { sessionId: result.sessionId },
+                    });
+                    return JSON.stringify({
+                        sessionId: result.sessionId,
+                        finalText: result.finalText,
+                        turns: result.turns,
+                        totalCostUsd: result.totalCostUsd,
+                        context: snap,
+                        contextWarning,
+                    }, null, 2);
+                },
+            }),
+            git_diff: tool({
+                description: 'Run git diff to see all current changes (staged + unstaged) relative to HEAD.',
+                args: {
+                    cwd: tool.schema.string().optional(),
+                },
+                async execute(_args, context) {
+                    annotateToolRun(context, 'Running git diff', {});
+                    const result = await services.manager.gitDiff();
+                    return JSON.stringify(result, null, 2);
+                },
+            }),
+            git_commit: tool({
+                description: 'Stage all changes and commit with the given message.',
+                args: {
+                    message: tool.schema.string().min(1),
+                    cwd: tool.schema.string().optional(),
+                },
+                async execute(args, context) {
+                    annotateToolRun(context, 'Committing changes', {
+                        message: args.message,
+                    });
+                    const result = await services.manager.gitCommit(args.message);
+                    return JSON.stringify(result, null, 2);
+                },
+            }),
+            git_reset: tool({
+                description: 'Run git reset --hard HEAD and git clean -fd to discard ALL uncommitted changes and untracked files.',
+                args: {
+                    cwd: tool.schema.string().optional(),
+                },
+                async execute(_args, context) {
+                    annotateToolRun(context, 'Resetting working directory', {});
+                    const result = await services.manager.gitReset();
+                    return JSON.stringify(result, null, 2);
+                },
+            }),
+            engineer_clear: tool({
+                description: 'Clear the active Claude Code session. The next send will start a fresh session. ' +
+                    'Use when context is full, the session is confused, or starting a different task.',
+                args: {
+                    cwd: tool.schema.string().optional(),
+                    reason: tool.schema.string().optional(),
+                },
+                async execute(args, context) {
+                    annotateToolRun(context, 'Clearing session', {
+                        reason: args.reason,
+                    });
+                    const clearedId = await services.manager.clearSession(args.cwd ?? context.worktree);
+                    return JSON.stringify({ clearedSessionId: clearedId });
+                },
+            }),
+            engineer_status: tool({
+                description: 'Get the current persistent session status: context usage %, turns, cost, active session ID.',
+                args: {
+                    cwd: tool.schema.string().optional(),
+                },
+                async execute(_args, context) {
+                    annotateToolRun(context, 'Checking session status', {});
+                    const status = services.manager.getStatus();
+                    return JSON.stringify({
+                        ...status,
+                        transcriptFile: status.sessionId
+                            ? `.claude-manager/transcripts/${status.sessionId}.json`
+                            : null,
+                        contextWarning: formatContextWarning(status),
+                    }, null, 2);
+                },
+            }),
+            engineer_metadata: tool({
+                description: 'Inspect Claude slash commands, skills, hooks, and repo settings.',
+                args: {
+                    cwd: tool.schema.string().optional(),
+                    includeSdkProbe: tool.schema.boolean().default(false),
+                },
+                async execute(args, context) {
+                    annotateToolRun(context, 'Collecting Claude metadata', {
+                        includeSdkProbe: args.includeSdkProbe,
+                    });
+                    const metadata = await services.sessions.inspectRepository(args.cwd ?? context.worktree, {
+                        includeSdkProbe: args.includeSdkProbe,
+                    });
+                    return JSON.stringify(metadata, null, 2);
+                },
+            }),
+            engineer_sessions: tool({
+                description: 'List Claude sessions or inspect a saved transcript. ' +
+                    'When sessionId is provided, returns both SDK transcript and local events.',
+                args: {
+                    cwd: tool.schema.string().optional(),
+                    sessionId: tool.schema.string().optional(),
+                },
+                async execute(args, context) {
+                    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),
+                        ]);
+                        return JSON.stringify({
+                            sdkTranscript,
+                            localEvents: localEvents.length > 0 ? localEvents : undefined,
+                        }, null, 2);
+                    }
+                    const sessions = await services.sessions.listSessions(cwd);
+                    return JSON.stringify(sessions, null, 2);
+                },
+            }),
+            engineer_runs: tool({
+                description: 'List persistent manager run records.',
+                args: {
+                    cwd: tool.schema.string().optional(),
+                    runId: tool.schema.string().optional(),
+                },
+                async execute(args, context) {
+                    annotateToolRun(context, 'Reading manager run state', {});
+                    if (args.runId) {
+                        const run = await services.manager.getRun(args.cwd ?? context.worktree, args.runId);
+                        return JSON.stringify(run, null, 2);
+                    }
+                    const runs = await services.manager.listRuns(args.cwd ?? context.worktree);
+                    return JSON.stringify(runs, null, 2);
+                },
+            }),
+            approval_policy: tool({
+                description: 'View the current tool approval policy: rules, default action, and enabled status.',
+                args: {},
+                async execute(_args, context) {
+                    annotateToolRun(context, 'Reading approval policy', {});
+                    return JSON.stringify(services.approvalManager.getPolicy(), null, 2);
+                },
+            }),
+            approval_decisions: tool({
+                description: 'View recent tool approval decisions. Shows what tools were allowed or denied. ' +
+                    'Use deniedOnly to see only denied calls.',
+                args: {
+                    limit: tool.schema.number().optional(),
+                    deniedOnly: tool.schema.boolean().optional(),
+                },
+                async execute(args, context) {
+                    annotateToolRun(context, 'Reading approval decisions', {});
+                    const decisions = args.deniedOnly
+                        ? services.approvalManager.getDeniedDecisions(args.limit)
+                        : services.approvalManager.getDecisions(args.limit);
+                    return JSON.stringify({ total: decisions.length, decisions }, null, 2);
+                },
+            }),
+            approval_update: tool({
+                description: 'Update the tool approval policy. Add/remove rules, change default action, or enable/disable. ' +
+                    'Rules are evaluated top-to-bottom; first match wins.',
+                args: {
+                    action: tool.schema.enum([
+                        'addRule',
+                        'removeRule',
+                        'setDefault',
+                        'setEnabled',
+                        'clearDecisions',
+                    ]),
+                    ruleId: tool.schema.string().optional(),
+                    toolPattern: tool.schema.string().optional(),
+                    inputPattern: tool.schema.string().optional(),
+                    ruleAction: tool.schema.enum(['allow', 'deny']).optional(),
+                    denyMessage: tool.schema.string().optional(),
+                    description: tool.schema.string().optional(),
+                    position: tool.schema.number().optional(),
+                    defaultAction: tool.schema.enum(['allow', 'deny']).optional(),
+                    enabled: tool.schema.boolean().optional(),
+                },
+                async execute(args, context) {
+                    annotateToolRun(context, `Updating approval: ${args.action}`, {});
+                    if (args.action === 'addRule') {
+                        if (!args.ruleId || !args.toolPattern || !args.ruleAction) {
+                            return JSON.stringify({
+                                error: 'addRule requires ruleId, toolPattern, and ruleAction',
+                            });
+                        }
+                        services.approvalManager.addRule({
+                            id: args.ruleId,
+                            toolPattern: args.toolPattern,
+                            inputPattern: args.inputPattern,
+                            action: args.ruleAction,
+                            denyMessage: args.denyMessage,
+                            description: args.description,
+                        }, args.position);
+                    }
+                    else if (args.action === 'removeRule') {
+                        if (!args.ruleId) {
+                            return JSON.stringify({ error: 'removeRule requires ruleId' });
+                        }
+                        const removed = services.approvalManager.removeRule(args.ruleId);
+                        return JSON.stringify({ removed });
+                    }
+                    else if (args.action === 'setDefault') {
+                        if (!args.defaultAction) {
+                            return JSON.stringify({
+                                error: 'setDefault requires defaultAction',
+                            });
+                        }
+                        services.approvalManager.setDefaultAction(args.defaultAction);
+                    }
+                    else if (args.action === 'setEnabled') {
+                        if (args.enabled === undefined) {
+                            return JSON.stringify({ error: 'setEnabled requires enabled' });
+                        }
+                        services.approvalManager.setEnabled(args.enabled);
+                    }
+                    else if (args.action === 'clearDecisions') {
+                        services.approvalManager.clearDecisions();
+                    }
+                    return JSON.stringify(services.approvalManager.getPolicy(), null, 2);
+                },
+            }),
+        },
+    };
+};
+function annotateToolRun(context, title, metadata) {
+    context.metadata({ title, metadata });
+}
+function formatContextWarning(context) {
+    const { warningLevel, estimatedContextPercent, totalTurns, totalCostUsd } = context;
+    if (warningLevel === 'ok' || estimatedContextPercent === null) {
+        return null;
+    }
+    const templates = managerPromptRegistry.contextWarnings;
+    const template = warningLevel === 'critical'
+        ? templates.critical
+        : warningLevel === 'high'
+            ? templates.high
+            : templates.moderate;
+    return template
+        .replace('{percent}', String(estimatedContextPercent))
+        .replace('{turns}', String(totalTurns))
+        .replace('{cost}', totalCostUsd.toFixed(2));
+}

package/dist/plugin/orchestrator.plugin.js

@@ -60,9 +60,11 @@ export const OrchestratorPlugin = async () => {
                 },
             };
             // ── Planning subagents ────────────────────────────────────────────
+            // Claude Code tools (Bash, Read, Write, Edit, …) are executed internally
+            // by the claude CLI subprocess and streamed back with providerExecuted:true.
+            // OpenCode's own tools must not be advertised to these agents.
             const claudeCodePermissions = {
-                '*': 'allow',
-                bash: 'allow',
+                '*': 'deny',
             };
             config.agent['claude-code-planning-opus'] ??= {
                 description: 'Claude Code Opus specialist for investigation, architecture, and planning.',

package/dist/plugin/service-factory.d.ts

@@ -0,0 +1,12 @@
+import { ClaudeSessionService } from '../claude/claude-session.service.js';
+import { SessionLiveTailer } from '../claude/session-live-tailer.js';
+import { ToolApprovalManager } from '../claude/tool-approval-manager.js';
+import { PersistentManager } from '../manager/persistent-manager.js';
+interface ClaudeManagerPluginServices {
+    manager: PersistentManager;
+    sessions: ClaudeSessionService;
+    approvalManager: ToolApprovalManager;
+    liveTailer: SessionLiveTailer;
+}
+export declare function getOrCreatePluginServices(worktree: string): ClaudeManagerPluginServices;
+export {};

package/dist/plugin/service-factory.js

@@ -0,0 +1,41 @@
+import { ClaudeAgentSdkAdapter } from '../claude/claude-agent-sdk-adapter.js';
+import { ClaudeSessionService } from '../claude/claude-session.service.js';
+import { SessionLiveTailer } from '../claude/session-live-tailer.js';
+import { ToolApprovalManager } from '../claude/tool-approval-manager.js';
+import { ClaudeMetadataService } from '../metadata/claude-metadata.service.js';
+import { RepoClaudeConfigReader } from '../metadata/repo-claude-config-reader.js';
+import { FileRunStateStore } from '../state/file-run-state-store.js';
+import { TranscriptStore } from '../state/transcript-store.js';
+import { ContextTracker } from '../manager/context-tracker.js';
+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 metadataService = new ClaudeMetadataService(new RepoClaudeConfigReader(), sdkAdapter);
+    const sessionService = new ClaudeSessionService(sdkAdapter, metadataService);
+    const contextTracker = new ContextTracker();
+    const sessionController = new SessionController(sdkAdapter, contextTracker, managerPromptRegistry.engineerSessionPrompt, 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,
+        sessions: sessionService,
+        approvalManager,
+        liveTailer,
+    };
+    serviceCache.set(worktree, services);
+    return services;
+}

package/dist/prompts/registry.d.ts

@@ -1,8 +1,2 @@
-/**
- * Agent prompt registry for the orchestrator + Claude Code subagent architecture.
- */
-export declare const prompts: {
-    orchestrator: string;
-    planningAgent: string;
-    buildAgent: string;
-};
+import type { ManagerPromptRegistry } from '../types/contracts.js';
+export declare const managerPromptRegistry: ManagerPromptRegistry;