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

package/README.md

@@ -4,17 +4,20 @@ This package provides an OpenCode plugin that lets an OpenCode-side agent hierar
 
 ## Overview
 
-Use this when you want OpenCode to act as a manager over Claude Code instead of talking to Claude directly. The plugin gives OpenCode a stable tool surface for delegating work to Claude Code sessions, managing session lifecycle (compact, clear, fresh start), reviewing changes via git, and inspecting session history.
+Use this when you want OpenCode to act like a real technical lead over Claude Code instead of being a thin relay. The plugin gives you a CTO agent that can ask better questions, explicitly assign named engineers, reuse each engineer's Claude session for continuity, preserve wrapper-level engineer memory, compare multiple plans, and keep git/review work at the manager layer.
 
 ## Features
 
 - Runs Claude Code tasks from OpenCode through `@anthropic-ai/claude-agent-sdk`.
-- Persistent sessions with `freshSession`, model, and effort controls for safe task isolation.
-- Context lifecycle: compact (preserve state) or clear (start fresh).
+- Creates a persistent named team: `Tom`, `John`, `Maya`, `Sara`, and `Alex`.
+- Reuses one Claude Code session per engineer within the active CTO team.
+- Reloads prior engineer wrapper context so each named subagent can prompt Claude better over time.
+- Uses named engineer subagents for live delegated work while keeping both wrapper memory and Claude session continuity underneath.
+- Keeps session babysitting out of the normal user flow — no public reset/fresh-session controls.
 - Discovers repo-local Claude metadata from `.claude/skills`, `.claude/commands`, `CLAUDE.md`, and settings hooks.
 - Git integration: diff, commit, and reset from the manager layer.
 - Tool approval policy for governing which Claude Code tools are allowed.
-- Optionally persists manager run records under `.claude-manager/runs` for post-hoc inspection (populated when tasks are executed through the run-tracking path).
+- Persists local team state and transcripts under `.claude-manager/` for continuity and inspection.
 
 ## Requirements
 
@@ -51,17 +54,17 @@ If you are testing locally, point OpenCode at the local package or plugin file u
 
 ## OpenCode tools
 
-### Engineer session
+### CTO orchestration
 
-- `explore` — investigate and analyze code without making edits. Read-only exploration of the codebase. Preferred first step before implementation.
-  - `message` (required) — the instruction to send.
-  - `freshSession` — set to `true` to clear the active session before sending. Use when switching to an unrelated task or when context is contaminated.
-  - `model` — `"claude-opus-4-6"` (default, recommended for most coding work), `"claude-sonnet-4-6"`, or `"claude-sonnet-4-5"` (faster/lighter tasks).
-  - `effort` — `"high"` (default), `"medium"` (lighter tasks), `"low"`, or `"max"` (especially hard problems).
-- `implement` — implement code changes; can read, edit, and create files. Use after exploration to make changes. Same args as `explore`.
-- `compact_context` — compress session history to reclaim context window space. Preserves state while reducing token usage.
-- `clear_session` — clear the active session to start fresh. Use when context is full or starting a new task.
-- `session_health` — check session health metrics: context usage %, turn count, cost, and session ID.
+- Use the built-in OpenCode `task` tool to delegate to named engineers: `tom`, `john`, `maya`, `sara`, `alex`.
+- `team_status` — inspect the current CTO team's engineer bindings, Claude session IDs, busy flags, and context snapshots.
+
+### Engineer bridge
+
+- `claude` — available only inside named engineer subagents. Sends work through that engineer's persistent Claude Code session.
+  - `mode` (required) — `explore`, `implement`, or `verify`.
+  - `message` (required) — the work to do.
+  - `model` (optional) — `claude-opus-4-6` or `claude-sonnet-4-6`.
 
 ### Git operations
 
@@ -72,7 +75,7 @@ If you are testing locally, point OpenCode at the local package or plugin file u
 ### Inspection
 
 - `list_transcripts` — list available session transcripts or inspect a specific transcript by ID.
-- `list_history` — list persistent run records from the manager or inspect a specific run.
+- `list_history` — list saved CTO teams for the worktree or inspect one team by ID.
 
 ### Tool approval
 
@@ -82,11 +85,11 @@ If you are testing locally, point OpenCode at the local package or plugin file u
 
 ## Agent hierarchy
 
-The plugin registers a CTO → Manager → Engineer hierarchy through the OpenCode plugin `config` hook:
+The plugin registers a CTO + named engineer team through the OpenCode plugin `config` hook:
 
-- **`cto`** (primary agent) — sets direction and orchestrates work by spawning `manager` subagents. Has read/search/web tools but does NOT operate Claude Code directly.
-- **`manager`** (subagent) — operates a Claude Code engineer through a persistent session. Has the full tool surface (`explore`, `implement`, `compact_context`, `clear_session`, `session_health`, `list_transcripts`, `list_history`, `git_*`, `approval_*`) plus read/search/web tools for investigation.
-- **Engineer** — the Claude Code persistent session itself (not an OpenCode agent). Receives instructions from the manager, executes code changes, and reports results.
+- **`cto`** (primary agent) — owns the outcome, finds missing requirements, spawns named engineers with the Task tool, compares plans, reviews diffs, and manages git.
+- **`tom`**, **`john`**, **`maya`**, **`sara`**, **`alex`** (subagents) — thin named engineer wrappers. Each uses the `claude` tool and keeps one persistent Claude Code session.
+- **Claude Code sessions** — the underlying execution layer. One session per engineer inside the active team.
 
 These are added to OpenCode config at runtime by the plugin, so they do not require separate manual `opencode.json` entries.
 
@@ -94,27 +97,21 @@ These are added to OpenCode config at runtime by the plugin, so they do not requ
 
 Typical flow inside OpenCode:
 
-1. Explore the codebase with `explore`.
-2. Implement changes with `implement`.
+1. Ask the `cto` agent for the work.
+2. Let `cto` spawn one or more named engineers with the Task tool.
 3. Review changes with `git_diff`, then commit or reset.
-4. Inspect saved Claude history with `list_transcripts` or prior orchestration records with `list_history`.
+4. Inspect saved Claude history with `list_transcripts` or saved team state with `list_history` / `team_status`.
 
 Example tasks:
 
 ```text
-Use implement to add the new validation logic in src/auth.ts, then review with git_diff.
-```
-
-Start a fresh session for an unrelated task:
-
-```text
-Use explore with freshSession:true to investigate the failing CI test in test/api.test.ts.
+Ask CTO to send Tom to implement the new validation logic in src/auth.ts, then review with git_diff.
 ```
 
-Reclaim context mid-session:
+For a larger feature where you want two independent plans first:
 
 ```text
-Use compact_context to free up context, then continue with the next implementation step.
+Ask CTO to spawn Maya and Alex in parallel to create two plans for the new billing feature, then synthesize the best combined plan.
 ```
 
 ## Local Development
@@ -176,6 +173,7 @@ After trusted publishing is working, you can tighten npm package security by dis
 
 - Claude slash commands and skills come primarily from filesystem discovery; SDK probing is available but optional.
 - Session state is local to the repo under `.claude-manager/` and is ignored by git.
+- The strongest team continuity comes when engineers are spawned from the active `cto` session; the plugin maps named engineers back to that active team automatically.
 - Context tracking is heuristic-based; actual SDK context usage may differ slightly.
 
 ## Scripts

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, AgentSlotType, RunningTask, SlotStatus, ManagerStatus, 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, EngineerName, EngineerWorkMode, WrapperHistoryEntry, TeamEngineerRecord, TeamRecord, EngineerTaskResult, PlanDraft, SynthesizedPlanResult, 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 { AgentSlotType, ClaudeSessionEvent, ClaudeSessionRunResult, GitDiffResult, GitOperationResult, ManagerStatus, PersistentRunRecord, PersistentRunResult, RunningTask, SessionContextSnapshot, SlotStatus } from '../types/contracts.js';
+import type { ClaudeSessionEvent, ClaudeSessionRunResult, PersistentRunRecord, PersistentRunResult, SessionContextSnapshot, GitDiffResult, GitOperationResult } 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,10 +12,6 @@ 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.
@@ -65,25 +61,9 @@ export declare class PersistentManager {
      */
     gitReset(): Promise<GitOperationResult>;
     /**
-     * Get current session status, context health, and slot usage.
+     * Get current session status and context health.
      */
-    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[];
+    getStatus(): SessionContextSnapshot;
     /**
      * Clear the active session. Next send creates a fresh one.
      */

package/dist/manager/persistent-manager.js

@@ -5,19 +5,6 @@ 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;
@@ -76,90 +63,10 @@ export class PersistentManager {
         return this.gitOps.resetHard();
     }
     /**
-     * Get current session status, context health, and slot usage.
+     * Get current session status and context health.
      */
     getStatus() {
-        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];
+        return this.sessionController.getContextSnapshot();
     }
     /**
      * Clear the active session. Next send creates a fresh one.

package/dist/manager/team-orchestrator.d.ts

@@ -0,0 +1,50 @@
+import type { ClaudeSessionEventHandler } from '../claude/claude-agent-sdk-adapter.js';
+import type { ClaudeSessionService } from '../claude/claude-session.service.js';
+import type { TeamStateStore } from '../state/team-state-store.js';
+import type { TranscriptStore } from '../state/transcript-store.js';
+import type { DiscoveredClaudeFile, EngineerName, EngineerTaskResult, EngineerWorkMode, SynthesizedPlanResult, TeamRecord } from '../types/contracts.js';
+interface DispatchEngineerInput {
+    teamId: string;
+    cwd: string;
+    engineer: EngineerName;
+    mode: EngineerWorkMode;
+    message: string;
+    model?: string;
+    abortSignal?: AbortSignal;
+    onEvent?: ClaudeSessionEventHandler;
+}
+export declare class TeamOrchestrator {
+    private readonly sessions;
+    private readonly teamStore;
+    private readonly transcriptStore;
+    private readonly engineerSessionPrompt;
+    private readonly projectClaudeFiles;
+    constructor(sessions: ClaudeSessionService, teamStore: TeamStateStore, transcriptStore: TranscriptStore, engineerSessionPrompt: string, projectClaudeFiles: DiscoveredClaudeFile[]);
+    getOrCreateTeam(cwd: string, teamId: string): Promise<TeamRecord>;
+    listTeams(cwd: string): Promise<TeamRecord[]>;
+    recordWrapperSession(cwd: string, teamId: string, engineer: EngineerName, wrapperSessionId: string): Promise<void>;
+    recordWrapperExchange(cwd: string, teamId: string, engineer: EngineerName, wrapperSessionId: string, mode: EngineerWorkMode, assignment: string, result: string): Promise<void>;
+    getWrapperSystemContext(cwd: string, teamId: string, engineer: EngineerName): Promise<string | null>;
+    findTeamByWrapperSession(cwd: string, wrapperSessionId: string): Promise<{
+        teamId: string;
+        engineer: EngineerName;
+    } | null>;
+    dispatchEngineer(input: DispatchEngineerInput): Promise<EngineerTaskResult>;
+    planWithTeam(input: {
+        teamId: string;
+        cwd: string;
+        request: string;
+        leadEngineer: EngineerName;
+        challengerEngineer: EngineerName;
+        model?: string;
+        abortSignal?: AbortSignal;
+    }): Promise<SynthesizedPlanResult>;
+    private updateEngineer;
+    private reserveEngineer;
+    private getEngineerState;
+    private normalizeTeamRecord;
+    private buildSessionSystemPrompt;
+    private buildEngineerPrompt;
+    private mapWorkModeToSessionMode;
+}
+export {};