@doingdev/opencode-claude-manager-plugin 0.1.10 → 0.1.12

package/README.md

@@ -4,13 +4,13 @@ This package provides an OpenCode plugin that lets an OpenCode-side manager agen
 
 ## 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 discovering Claude metadata, delegating work to Claude sessions, splitting tasks into subagents, and coordinating optional git worktrees.
+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 discovering Claude metadata, delegating work to Claude sessions, and splitting tasks into subagents (all using the same working directory).
 
 ## Features
 
 - Runs Claude Code tasks from OpenCode through `@anthropic-ai/claude-agent-sdk`.
 - Discovers repo-local Claude metadata from `.claude/skills`, `.claude/commands`, `CLAUDE.md`, and settings hooks.
-- Splits multi-step tasks into subagents, optionally assigning dedicated git worktrees.
+- Splits multi-step tasks into subagents that run sequentially in the same repository directory.
 - Persists manager runs under `.claude-manager/runs` so sessions can be inspected later.
 - Exposes manager-facing tools instead of relying on undocumented plugin-defined slash commands.
 
@@ -19,21 +19,20 @@ Use this when you want OpenCode to act as a manager over Claude Code instead of
 - Node `22+`
 - OpenCode with plugin loading enabled
 - Access to Claude Code / Claude Agent SDK on the machine where OpenCode is running
-- A git repository if you want automatic worktree allocation
 
 ## Installation
 
-Install from npm:
+Install from the npm registry:
 
 ```bash
-npm install @doingdev/opencode-claude-manager-plugin
+pnpm add @doingdev/opencode-claude-manager-plugin
 ```
 
 Or for local development in this repo:
 
 ```bash
-npm install
-npm run build
+pnpm install
+pnpm run build
 ```
 
 ## OpenCode Config
@@ -50,11 +49,10 @@ If you are testing locally, point OpenCode at the local package or plugin file u
 
 ## OpenCode tools
 
-- `claude_manager_run` - run a task through Claude with optional splitting and worktrees; returns a compact output summary and a `runId` for deeper inspection
+- `claude_manager_run` - run a task through Claude with optional splitting into subagents; returns a compact output summary and a `runId` for deeper inspection
 - `claude_manager_metadata` - inspect available Claude commands, skills, hooks, and settings
 - `claude_manager_sessions` - list Claude sessions or inspect a saved transcript
 - `claude_manager_runs` - inspect persisted manager run records
-- `claude_manager_cleanup_run` - explicitly remove worktrees created for a prior manager run
 
 ## Plugin-provided agents and commands
 
@@ -77,7 +75,7 @@ Typical flow inside OpenCode:
 Example task:
 
 ```text
-Use claude_manager_run to split this implementation into subagents, use worktrees, and summarize the final result.
+Use claude_manager_run to split this implementation into subagents and summarize the final result.
 ```
 
 ## Local Development
@@ -85,11 +83,11 @@ Use claude_manager_run to split this implementation into subagents, use worktree
 Clone the repo and run:
 
 ```bash
-npm install
-npm run lint
-npm run typecheck
-npm run test
-npm run build
+pnpm install
+pnpm run lint
+pnpm run typecheck
+pnpm run test
+pnpm run build
 ```
 
 The compiled plugin output is written to `dist/`.
@@ -119,13 +117,13 @@ Notes for trusted publishing:
 Release flow:
 
 ```bash
-npm login
-npm whoami
-npm version patch
-npm run lint
-npm run typecheck
-npm run test
-npm run build
+pnpm login
+pnpm whoami
+pnpm version patch
+pnpm run lint
+pnpm run typecheck
+pnpm run test
+pnpm run build
 ```
 
 Then publish from GitHub by either:
@@ -138,14 +136,13 @@ After trusted publishing is working, you can tighten npm package security by dis
 ## Limitations
 
 - Claude slash commands and skills come primarily from filesystem discovery; SDK probing is available but optional.
-- Worktree creation only activates when the current directory is a git repo and multiple subtasks are planned.
-- Worktrees are preserved by default so you can inspect changes; clean them up explicitly with `claude_manager_cleanup_run`.
+- Multiple subagents share one working directory and run one after another to avoid overlapping edits.
 - Run state is local to the repo under `.claude-manager/` and is ignored by git.
 
 ## Scripts
 
-- `npm run build`
-- `npm run typecheck`
-- `npm run lint`
-- `npm run format`
-- `npm run test`
+- `pnpm run build`
+- `pnpm run typecheck`
+- `pnpm run lint`
+- `pnpm run format`
+- `pnpm run test`

package/dist/claude/claude-agent-sdk-adapter.d.ts

@@ -1,7 +1,7 @@
 import { type Options, type Query, type SDKSessionInfo, type SessionMessage, type SettingSource } from '@anthropic-ai/claude-agent-sdk';
 import type { ClaudeCapabilitySnapshot, ClaudeSessionEvent, ClaudeSessionRunResult, ClaudeSessionSummary, ClaudeSessionTranscriptMessage, RunClaudeSessionInput } from '../types/contracts.js';
 export type ClaudeSessionEventHandler = (event: ClaudeSessionEvent) => void | Promise<void>;
-export interface ClaudeAgentSdkFacade {
+interface ClaudeAgentSdkFacade {
     query(params: {
         prompt: string;
         options?: Options;
@@ -22,3 +22,4 @@ export declare class ClaudeAgentSdkAdapter {
     probeCapabilities(cwd: string, settingSources?: SettingSource[]): Promise<ClaudeCapabilitySnapshot>;
     private buildOptions;
 }
+export {};

package/dist/claude/claude-agent-sdk-adapter.js

@@ -1,39 +1,59 @@
 import { getSessionMessages, listSessions, query, } from '@anthropic-ai/claude-agent-sdk';
+import { appendTranscriptEvents } from '../util/transcript-append.js';
 const defaultFacade = {
     query,
     listSessions,
     getSessionMessages,
 };
+const TOOL_INPUT_PREVIEW_MAX = 2000;
+const USER_MESSAGE_MAX = 4000;
 export class ClaudeAgentSdkAdapter {
     sdkFacade;
     constructor(sdkFacade = defaultFacade) {
         this.sdkFacade = sdkFacade;
     }
     async runSession(input, onEvent) {
+        const options = this.buildOptions(input);
+        const includePartials = options.includePartialMessages === true;
         const sessionQuery = this.sdkFacade.query({
             prompt: input.prompt,
-            options: this.buildOptions(input),
+            options,
         });
-        const events = [];
+        let events = [];
         let finalText = '';
         let sessionId;
         let turns;
         let totalCostUsd;
+        let inputTokens;
+        let outputTokens;
+        let contextWindowSize;
         try {
             for await (const message of sessionQuery) {
-                const event = normalizeSdkMessage(message);
-                if (!event) {
-                    continue;
+                const batch = normalizeSdkMessages(message, includePartials);
+                for (const event of batch) {
+                    sessionId ??= event.sessionId;
+                    if (event.type === 'result') {
+                        finalText = event.text;
+                        turns = event.turns;
+                        totalCostUsd = event.totalCostUsd;
+                    }
+                    events = appendTranscriptEvents(events, [event]);
+                    if (onEvent) {
+                        await onEvent(event);
+                    }
                 }
-                sessionId ??= event.sessionId;
-                if (event.type === 'result') {
-                    finalText = event.text;
-                    turns = event.turns;
-                    totalCostUsd = event.totalCostUsd;
-                }
-                events.push(event);
-                if (onEvent) {
-                    await onEvent(event);
+                // Extract usage data from result messages
+                if (message.type === 'result') {
+                    const usage = extractUsageFromResult(message);
+                    if (usage.inputTokens !== undefined) {
+                        inputTokens = usage.inputTokens;
+                    }
+                    if (usage.outputTokens !== undefined) {
+                        outputTokens = usage.outputTokens;
+                    }
+                    if (usage.contextWindowSize !== undefined) {
+                        contextWindowSize = usage.contextWindowSize;
+                    }
                 }
             }
         }
@@ -46,6 +66,9 @@ export class ClaudeAgentSdkAdapter {
             finalText,
             turns,
             totalCostUsd,
+            inputTokens,
+            outputTokens,
+            contextWindowSize,
         };
     }
     async listSavedSessions(cwd) {
@@ -125,73 +148,210 @@ export class ClaudeAgentSdkAdapter {
         return options;
     }
 }
-function normalizeSdkMessage(message) {
+function normalizeSdkMessages(message, includePartials) {
     const sessionId = 'session_id' in message ? message.session_id : undefined;
     if (message.type === 'assistant') {
-        return {
-            type: 'assistant',
-            sessionId,
-            text: extractText(message.message),
-            rawType: message.type,
-        };
+        return normalizeAssistantSdkMessage(message, sessionId);
     }
     if (message.type === 'stream_event') {
+        if (!includePartials) {
+            return [];
+        }
         const partialText = extractPartialEventText(message.event);
         if (!partialText) {
-            return null;
+            return [];
         }
-        return {
-            type: 'partial',
-            sessionId,
-            text: partialText,
-            rawType: message.type,
-        };
+        return [
+            {
+                type: 'partial',
+                sessionId,
+                text: partialText,
+                rawType: message.type,
+            },
+        ];
     }
     if (message.type === 'result') {
-        return {
-            type: message.is_error ? 'error' : 'result',
-            sessionId,
-            text: message.subtype === 'success'
-                ? message.result
-                : message.errors.join('\n') || message.subtype,
-            turns: message.num_turns,
-            totalCostUsd: message.total_cost_usd,
-            rawType: `${message.type}:${message.subtype}`,
-        };
+        return [
+            {
+                type: message.is_error ? 'error' : 'result',
+                sessionId,
+                text: message.subtype === 'success'
+                    ? message.result
+                    : message.errors.join('\n') || message.subtype,
+                turns: message.num_turns,
+                totalCostUsd: message.total_cost_usd,
+                rawType: `${message.type}:${message.subtype}`,
+            },
+        ];
     }
     if (message.type === 'system') {
-        return {
-            type: message.subtype === 'init' ? 'init' : 'system',
-            sessionId,
-            text: message.subtype,
-            rawType: `${message.type}:${message.subtype}`,
-        };
+        return [
+            {
+                type: message.subtype === 'init' ? 'init' : 'system',
+                sessionId,
+                text: message.subtype,
+                rawType: `${message.type}:${message.subtype}`,
+            },
+        ];
     }
     if (message.type === 'auth_status') {
-        return {
-            type: 'system',
-            sessionId,
-            text: message.output.join('\n') || 'auth_status',
-            rawType: message.type,
-        };
+        return [
+            {
+                type: 'system',
+                sessionId,
+                text: message.output.join('\n') || 'auth_status',
+                rawType: message.type,
+            },
+        ];
     }
     if (message.type === 'prompt_suggestion') {
-        return {
+        return [
+            {
+                type: 'system',
+                sessionId,
+                text: message.suggestion,
+                rawType: message.type,
+            },
+        ];
+    }
+    if (message.type === 'user') {
+        return normalizeUserSdkMessage(message, sessionId);
+    }
+    return [
+        {
             type: 'system',
             sessionId,
-            text: message.suggestion,
+            text: message.type,
             rawType: message.type,
-        };
-    }
-    if (message.type === 'user') {
-        return null;
+        },
+    ];
+}
+function normalizeAssistantSdkMessage(message, sessionId) {
+    const raw = message.message;
+    if (!isRecord(raw) || !Array.isArray(raw.content)) {
+        const text = extractText(raw);
+        return text.trim()
+            ? [
+                {
+                    type: 'assistant',
+                    sessionId,
+                    text,
+                    rawType: 'assistant',
+                },
+            ]
+            : [];
     }
-    return {
-        type: 'system',
-        sessionId,
-        text: message.type,
-        rawType: message.type,
+    const out = [];
+    let textBuffer = '';
+    const flushText = () => {
+        if (textBuffer.trim()) {
+            out.push({
+                type: 'assistant',
+                sessionId,
+                text: textBuffer,
+                rawType: 'assistant',
+            });
+        }
+        textBuffer = '';
     };
+    for (const block of raw.content) {
+        if (!isRecord(block)) {
+            continue;
+        }
+        if (block.type === 'text' && typeof block.text === 'string') {
+            textBuffer += block.text;
+        }
+        else if (block.type === 'tool_use' && typeof block.name === 'string') {
+            flushText();
+            const id = typeof block.id === 'string' ? block.id : '';
+            const preview = truncateJsonish(block.input, TOOL_INPUT_PREVIEW_MAX);
+            out.push({
+                type: 'tool_call',
+                sessionId,
+                text: JSON.stringify({
+                    name: block.name,
+                    id,
+                    input: preview,
+                }),
+                rawType: 'assistant:tool_use',
+            });
+        }
+    }
+    flushText();
+    return out;
+}
+function normalizeUserSdkMessage(message, sessionId) {
+    let payload = serializeUserMessageContent(message.message);
+    if (message.tool_use_result !== undefined) {
+        const extra = truncateJsonish(message.tool_use_result, 1500);
+        if (extra) {
+            payload = payload
+                ? `${payload}\n[tool_use_result] ${extra}`
+                : `[tool_use_result] ${extra}`;
+        }
+    }
+    payload = truncateString(payload, USER_MESSAGE_MAX);
+    if (!payload.trim()) {
+        return [];
+    }
+    return [
+        {
+            type: 'user',
+            sessionId,
+            text: payload,
+            rawType: 'user',
+        },
+    ];
+}
+function serializeUserMessageContent(message) {
+    if (typeof message === 'string') {
+        return message;
+    }
+    if (!isRecord(message)) {
+        return '';
+    }
+    const content = message.content;
+    if (typeof content === 'string') {
+        return content;
+    }
+    if (!Array.isArray(content)) {
+        return truncateJsonish(message, USER_MESSAGE_MAX);
+    }
+    const lines = [];
+    for (const part of content) {
+        if (!isRecord(part)) {
+            continue;
+        }
+        if (part.type === 'text' && typeof part.text === 'string') {
+            lines.push(part.text);
+        }
+        else if (part.type === 'tool_result') {
+            const id = typeof part.tool_use_id === 'string' ? part.tool_use_id : '';
+            const body = truncateJsonish(part.content, TOOL_INPUT_PREVIEW_MAX);
+            lines.push(`[tool_result:${id}] ${body}`);
+        }
+    }
+    return lines.filter(Boolean).join('\n');
+}
+function truncateJsonish(value, max) {
+    if (value === undefined || value === null) {
+        return '';
+    }
+    if (typeof value === 'string') {
+        return truncateString(value, max);
+    }
+    try {
+        return truncateString(JSON.stringify(value), max);
+    }
+    catch {
+        return truncateString(String(value), max);
+    }
+}
+function truncateString(s, max) {
+    if (s.length <= max) {
+        return s;
+    }
+    return s.slice(0, max);
 }
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
@@ -257,3 +417,30 @@ function mapAgent(agent) {
         source: 'sdk',
     };
 }
+function extractUsageFromResult(message) {
+    if (message.type !== 'result') {
+        return {};
+    }
+    const result = {};
+    // Extract from usage field
+    const usage = message.usage;
+    if (isRecord(usage)) {
+        if (typeof usage.input_tokens === 'number') {
+            result.inputTokens = usage.input_tokens;
+        }
+        if (typeof usage.output_tokens === 'number') {
+            result.outputTokens = usage.output_tokens;
+        }
+    }
+    // Extract contextWindow from modelUsage
+    const modelUsage = message.model_usage;
+    if (isRecord(modelUsage)) {
+        for (const model of Object.values(modelUsage)) {
+            if (isRecord(model) && typeof model.context_window === 'number') {
+                result.contextWindowSize = model.context_window;
+                break;
+            }
+        }
+    }
+    return result;
+}

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import type { Plugin } from '@opencode-ai/plugin';
 import { ClaudeManagerPlugin } from './plugin/claude-manager.plugin.js';
-export type { ClaudeCapabilitySnapshot, ClaudeMetadataSnapshot, ClaudeSessionRunResult, ClaudeSessionSummary, ClaudeSessionTranscriptMessage, ManagerRunRecord, ManagerRunResult, ManagerTaskRequest, ManagerPromptRegistry, RunClaudeSessionInput, } from './types/contracts.js';
+export type { ClaudeCapabilitySnapshot, ClaudeMetadataSnapshot, ClaudeSessionRunResult, ClaudeSessionSummary, ClaudeSessionTranscriptMessage, ManagerPromptRegistry, RunClaudeSessionInput, SessionContextSnapshot, GitDiffResult, GitOperationResult, PersistentRunRecord, PersistentRunResult, ActiveSessionState, ContextWarningLevel, } from './types/contracts.js';
 export { ClaudeManagerPlugin };
 export declare const plugin: Plugin;

package/dist/manager/context-tracker.d.ts

@@ -0,0 +1,33 @@
+import type { ContextWarningLevel, SessionContextSnapshot } from '../types/contracts.js';
+export declare class ContextTracker {
+    private totalTurns;
+    private totalCostUsd;
+    private latestInputTokens;
+    private latestOutputTokens;
+    private contextWindowSize;
+    private compactionCount;
+    private sessionId;
+    recordResult(result: {
+        sessionId?: string;
+        turns?: number;
+        totalCostUsd?: number;
+        inputTokens?: number;
+        outputTokens?: number;
+        contextWindowSize?: number;
+    }): void;
+    recordCompaction(): void;
+    snapshot(): SessionContextSnapshot;
+    warningLevel(): ContextWarningLevel;
+    estimateContextPercent(): number | null;
+    isAboveTokenThreshold(thresholdTokens?: number): boolean;
+    reset(): void;
+    /** Restore from persisted active session state. */
+    restore(state: {
+        sessionId: string;
+        totalTurns: number;
+        totalCostUsd: number;
+        estimatedContextPercent: number | null;
+        contextWindowSize: number | null;
+        latestInputTokens: number | null;
+    }): void;
+}

package/dist/manager/context-tracker.js

@@ -0,0 +1,108 @@
+const DEFAULT_CONTEXT_WINDOW = 200_000;
+export class ContextTracker {
+    totalTurns = 0;
+    totalCostUsd = 0;
+    latestInputTokens = null;
+    latestOutputTokens = null;
+    contextWindowSize = null;
+    compactionCount = 0;
+    sessionId = null;
+    recordResult(result) {
+        if (result.sessionId) {
+            this.sessionId = result.sessionId;
+        }
+        if (result.turns !== undefined) {
+            this.totalTurns = result.turns;
+        }
+        if (result.totalCostUsd !== undefined) {
+            this.totalCostUsd = result.totalCostUsd;
+        }
+        if (result.inputTokens !== undefined) {
+            // If input tokens dropped significantly, compaction likely occurred
+            if (this.latestInputTokens !== null &&
+                result.inputTokens < this.latestInputTokens * 0.5) {
+                this.compactionCount++;
+            }
+            this.latestInputTokens = result.inputTokens;
+        }
+        if (result.outputTokens !== undefined) {
+            this.latestOutputTokens = result.outputTokens;
+        }
+        if (result.contextWindowSize !== undefined) {
+            this.contextWindowSize = result.contextWindowSize;
+        }
+    }
+    recordCompaction() {
+        this.compactionCount++;
+    }
+    snapshot() {
+        return {
+            sessionId: this.sessionId,
+            totalTurns: this.totalTurns,
+            totalCostUsd: this.totalCostUsd,
+            latestInputTokens: this.latestInputTokens,
+            latestOutputTokens: this.latestOutputTokens,
+            contextWindowSize: this.contextWindowSize,
+            estimatedContextPercent: this.estimateContextPercent(),
+            warningLevel: this.warningLevel(),
+            compactionCount: this.compactionCount,
+        };
+    }
+    warningLevel() {
+        const percent = this.estimateContextPercent();
+        if (percent === null) {
+            return 'ok';
+        }
+        if (percent >= 85) {
+            return 'critical';
+        }
+        if (percent >= 70) {
+            return 'high';
+        }
+        if (percent >= 50) {
+            return 'moderate';
+        }
+        return 'ok';
+    }
+    estimateContextPercent() {
+        // Tier 1: Token-based (most accurate)
+        if (this.latestInputTokens !== null) {
+            const window = this.contextWindowSize ?? DEFAULT_CONTEXT_WINDOW;
+            return Math.min(100, Math.round((this.latestInputTokens / window) * 100));
+        }
+        // Tier 2: Cost-based heuristic
+        if (this.totalCostUsd > 0) {
+            const estimatedTokens = this.totalCostUsd * 130_000;
+            const window = this.contextWindowSize ?? DEFAULT_CONTEXT_WINDOW;
+            return Math.min(100, Math.round((estimatedTokens / window) * 100));
+        }
+        // Tier 3: Turns-based fallback
+        if (this.totalTurns > 0) {
+            const estimatedTokens = this.totalTurns * 6_000;
+            const window = this.contextWindowSize ?? DEFAULT_CONTEXT_WINDOW;
+            return Math.min(100, Math.round((estimatedTokens / window) * 100));
+        }
+        return null;
+    }
+    isAboveTokenThreshold(thresholdTokens = 200_000) {
+        return (this.latestInputTokens !== null &&
+            this.latestInputTokens >= thresholdTokens);
+    }
+    reset() {
+        this.totalTurns = 0;
+        this.totalCostUsd = 0;
+        this.latestInputTokens = null;
+        this.latestOutputTokens = null;
+        this.contextWindowSize = null;
+        this.compactionCount = 0;
+        this.sessionId = null;
+    }
+    /** Restore from persisted active session state. */
+    restore(state) {
+        this.sessionId = state.sessionId;
+        this.totalTurns = state.totalTurns;
+        this.totalCostUsd = state.totalCostUsd;
+        this.contextWindowSize = state.contextWindowSize;
+        this.latestInputTokens = state.latestInputTokens;
+    }
+}

package/dist/manager/git-operations.d.ts

@@ -0,0 +1,12 @@
+import type { GitDiffResult, GitOperationResult } from '../types/contracts.js';
+export declare class GitOperations {
+    private readonly cwd;
+    constructor(cwd: string);
+    diff(): Promise<GitDiffResult>;
+    diffStat(): Promise<string>;
+    commit(message: string): Promise<GitOperationResult>;
+    resetHard(): Promise<GitOperationResult>;
+    currentBranch(): Promise<string>;
+    recentCommits(count?: number): Promise<string>;
+    private git;
+}