@doingdev/opencode-claude-manager-plugin 0.1.4 → 0.1.6

package/README.md

@@ -50,7 +50,7 @@ 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
+- `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_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

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

@@ -136,10 +136,14 @@ function normalizeSdkMessage(message) {
         };
     }
     if (message.type === 'stream_event') {
+        const partialText = extractPartialEventText(message.event);
+        if (!partialText) {
+            return null;
+        }
         return {
             type: 'partial',
             sessionId,
-            text: extractPartialEventText(message.event),
+            text: partialText,
             rawType: message.type,
         };
     }
@@ -191,21 +195,21 @@ function normalizeSdkMessage(message) {
 }
 function extractPartialEventText(event) {
     if (!event || typeof event !== 'object') {
-        return 'stream_event';
+        return null;
     }
     const eventRecord = event;
-    const eventType = typeof eventRecord.type === 'string' ? eventRecord.type : 'stream_event';
     const delta = eventRecord.delta;
     if (delta && typeof delta === 'object') {
         const deltaRecord = delta;
-        if (typeof deltaRecord.text === 'string') {
+        if (typeof deltaRecord.text === 'string' && deltaRecord.text.length > 0) {
             return deltaRecord.text;
         }
-        if (typeof deltaRecord.partial_json === 'string') {
+        if (typeof deltaRecord.partial_json === 'string' &&
+            deltaRecord.partial_json.length > 0) {
             return deltaRecord.partial_json;
         }
     }
-    return eventType;
+    return null;
 }
 function extractText(payload) {
     if (typeof payload === 'string') {

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

@@ -3,16 +3,18 @@ import type { FileRunStateStore } from '../state/file-run-state-store.js';
 import type { ManagerRunRecord, ManagerRunResult, ManagerTaskRequest } from '../types/contracts.js';
 import type { WorktreeCoordinator } from '../worktree/worktree-coordinator.js';
 import type { TaskPlanner } from './task-planner.js';
+export type ManagerRunProgressHandler = (run: ManagerRunRecord) => void | Promise<void>;
 export declare class ManagerOrchestrator {
     private readonly sessionService;
     private readonly stateStore;
     private readonly worktreeCoordinator;
     private readonly taskPlanner;
     constructor(sessionService: ClaudeSessionService, stateStore: FileRunStateStore, worktreeCoordinator: WorktreeCoordinator, taskPlanner: TaskPlanner);
-    run(request: ManagerTaskRequest): Promise<ManagerRunResult>;
+    run(request: ManagerTaskRequest, onProgress?: ManagerRunProgressHandler): Promise<ManagerRunResult>;
     listRuns(cwd: string): Promise<ManagerRunRecord[]>;
     getRun(cwd: string, runId: string): Promise<ManagerRunRecord | null>;
     cleanupRunWorktrees(cwd: string, runId: string): Promise<ManagerRunRecord | null>;
     private executePlan;
     private patchSession;
+    private updateRunAndNotify;
 }

package/dist/manager/manager-orchestrator.js

@@ -11,7 +11,7 @@ export class ManagerOrchestrator {
         this.worktreeCoordinator = worktreeCoordinator;
         this.taskPlanner = taskPlanner;
     }
-    async run(request) {
+    async run(request, onProgress) {
         const mode = request.mode ?? 'auto';
         const maxSubagents = Math.max(1, request.maxSubagents ?? 3);
         const useWorktrees = request.useWorktrees ?? maxSubagents > 1;
@@ -44,6 +44,7 @@ export class ManagerOrchestrator {
             sessions: plannedAssignments.map(({ plan, assignment }) => createManagedSessionRecord(plan, assignment.cwd, assignment)),
         };
         await this.stateStore.saveRun(runRecord);
+        await onProgress?.(runRecord);
         const canRunInParallel = plannedAssignments.every(({ assignment }) => assignment.mode === 'git-worktree');
         const settledResults = canRunInParallel
             ? await Promise.allSettled(plannedAssignments.map(({ plan, assignment }) => this.executePlan({
@@ -52,6 +53,7 @@ export class ManagerOrchestrator {
                 plan,
                 assignment,
                 includeProjectSettings,
+                onProgress,
             })))
             : await runSequentially(plannedAssignments.map(({ plan, assignment }) => () => this.executePlan({
                 request,
@@ -59,14 +61,15 @@ export class ManagerOrchestrator {
                 plan,
                 assignment,
                 includeProjectSettings,
+                onProgress,
             })));
         const failedResult = settledResults.find((result) => result.status === 'rejected');
-        const finalRun = await this.stateStore.updateRun(request.cwd, runId, (currentRun) => ({
+        const finalRun = await this.updateRunAndNotify(request.cwd, runId, (currentRun) => ({
             ...currentRun,
             status: failedResult ? 'failed' : 'completed',
             updatedAt: new Date().toISOString(),
             finalSummary: summarizeRun(currentRun.sessions),
-        }));
+        }), onProgress);
         return { run: finalRun };
     }
     listRuns(cwd) {
@@ -94,11 +97,11 @@ export class ManagerOrchestrator {
         return run;
     }
     async executePlan(input) {
-        const { request, runId, plan, assignment, includeProjectSettings } = input;
+        const { request, runId, plan, assignment, includeProjectSettings, onProgress, } = input;
         await this.patchSession(request.cwd, runId, plan.id, (session) => ({
             ...session,
             status: 'running',
-        }));
+        }), onProgress);
         try {
             const sessionResult = await this.sessionService.runTask({
                 cwd: assignment.cwd,
@@ -112,7 +115,7 @@ export class ManagerOrchestrator {
                     ...session,
                     claudeSessionId: event.sessionId ?? session.claudeSessionId,
                     events: [...session.events, compactEvent(event)],
-                }));
+                }), onProgress);
             });
             await this.patchSession(request.cwd, runId, plan.id, (session) => ({
                 ...session,
@@ -121,23 +124,28 @@ export class ManagerOrchestrator {
                 finalText: sessionResult.finalText,
                 turns: sessionResult.turns,
                 totalCostUsd: sessionResult.totalCostUsd,
-            }));
+            }), onProgress);
         }
         catch (error) {
             await this.patchSession(request.cwd, runId, plan.id, (session) => ({
                 ...session,
                 status: 'failed',
                 error: error instanceof Error ? error.message : String(error),
-            }));
+            }), onProgress);
             throw error;
         }
     }
-    async patchSession(cwd, runId, sessionId, update) {
-        await this.stateStore.updateRun(cwd, runId, (run) => ({
+    async patchSession(cwd, runId, sessionId, update, onProgress) {
+        await this.updateRunAndNotify(cwd, runId, (run) => ({
             ...run,
             updatedAt: new Date().toISOString(),
             sessions: run.sessions.map((session) => session.id === sessionId ? update(session) : session),
-        }));
+        }), onProgress);
+    }
+    async updateRunAndNotify(cwd, runId, update, onProgress) {
+        const updatedRun = await this.stateStore.updateRun(cwd, runId, update);
+        await onProgress?.(updatedRun);
+        return updatedRun;
     }
 }
 function createManagedSessionRecord(plan, cwd, assignment) {

package/dist/plugin/claude-manager.plugin.d.ts

@@ -1,2 +1,4 @@
 import { type Plugin } from '@opencode-ai/plugin';
+import type { ManagerRunRecord } from '../types/contracts.js';
 export declare const ClaudeManagerPlugin: Plugin;
+export declare function formatManagerRunToolResult(run: ManagerRunRecord): string;

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

@@ -68,10 +68,11 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
             config.command['claude-run'] ??= {
                 description: 'Delegate a task to Claude Code through the manager plugin.',
                 agent: 'claude-manager',
+                subtask: true,
                 template: [
-                    'Use claude_manager_run to delegate the following task to Claude Code:',
+                    'Call claude_manager_run immediately for the following task:',
                     '$ARGUMENTS',
-                    'Default to worktrees for multi-part work and return a concise result summary.',
+                    'Avoid planning narration before the tool call. After it completes, return a concise result summary.',
                 ].join('\n\n'),
             };
             config.command['claude-sessions'] ??= {
@@ -85,6 +86,12 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                 ].join('\n\n'),
             };
         },
+        'command.execute.before': async (input, output) => {
+            const commandText = buildCommandText(input.command, input.arguments);
+            if (commandText) {
+                output.parts = rewriteCommandParts(output.parts, commandText);
+            }
+        },
         tool: {
             claude_manager_run: tool({
                 description: 'Delegate a task to Claude Code with optional subagents and worktrees.',
@@ -102,6 +109,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                         task: args.task,
                         mode: args.mode,
                     });
+                    let lastProgressSignature = '';
                     const result = await services.manager.run({
                         cwd: args.cwd ?? context.worktree,
                         task: args.task,
@@ -110,8 +118,16 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                         useWorktrees: args.useWorktrees,
                         includeProjectSettings: args.includeProjectSettings,
                         model: args.model,
+                    }, async (run) => {
+                        const progressView = buildRunProgressView(run);
+                        const signature = JSON.stringify(progressView);
+                        if (signature === lastProgressSignature) {
+                            return;
+                        }
+                        lastProgressSignature = signature;
+                        context.metadata(progressView);
                     });
-                    return JSON.stringify(result.run, null, 2);
+                    return formatManagerRunToolResult(result.run);
                 },
             }),
             claude_manager_metadata: tool({
@@ -182,3 +198,158 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
 function annotateToolRun(context, title, metadata) {
     context.metadata({ title, metadata });
 }
+function buildCommandText(command, rawArguments) {
+    const argumentsText = rawArguments.trim();
+    if (command === 'claude-run') {
+        return [
+            'Call `claude_manager_run` immediately.',
+            argumentsText
+                ? `Task: ${argumentsText}`
+                : 'Task: Inspect the current repository and wait for follow-up instructions.',
+            'Do not add planning text before the tool call. After it completes, give a short result summary.',
+        ].join('\n\n');
+    }
+    if (command === 'claude-metadata') {
+        return [
+            'Call `claude_manager_metadata` immediately for the current repository.',
+            argumentsText ? `Focus: ${argumentsText}` : '',
+            'Then summarize the discovered Claude commands, skills, hooks, agents, and config files briefly.',
+        ]
+            .filter(Boolean)
+            .join('\n\n');
+    }
+    if (command === 'claude-sessions') {
+        return [
+            'Call `claude_manager_sessions` and `claude_manager_runs` immediately for the current repository.',
+            argumentsText ? `Focus: ${argumentsText}` : '',
+            'Then summarize the most relevant recent Claude activity briefly.',
+        ]
+            .filter(Boolean)
+            .join('\n\n');
+    }
+    return null;
+}
+function rewriteCommandParts(parts, text) {
+    let hasRewrittenText = false;
+    const rewrittenParts = parts.map((part) => {
+        if (part.type !== 'text' || hasRewrittenText) {
+            return part;
+        }
+        hasRewrittenText = true;
+        return {
+            ...part,
+            text,
+        };
+    });
+    return rewrittenParts;
+}
+export function formatManagerRunToolResult(run) {
+    const finalSummary = run.finalSummary ?? summarizeSessionOutputs(run.sessions);
+    const output = run.sessions.length === 1
+        ? resolveSessionOutput(run.sessions[0])
+        : finalSummary;
+    return JSON.stringify({
+        runId: run.id,
+        status: run.status,
+        output,
+        finalSummary,
+        sessions: run.sessions.map((session) => ({
+            title: session.title,
+            status: session.status,
+            output: resolveSessionOutput(session),
+            claudeSessionId: session.claudeSessionId,
+            worktreeMode: session.worktreeMode,
+            branchName: session.branchName,
+            turns: session.turns,
+            totalCostUsd: session.totalCostUsd,
+        })),
+        inspectRun: {
+            tool: 'claude_manager_runs',
+            runId: run.id,
+        },
+    }, null, 2);
+}
+function buildRunProgressView(run) {
+    const completed = run.sessions.filter((session) => session.status === 'completed').length;
+    const failed = run.sessions.filter((session) => session.status === 'failed').length;
+    const running = run.sessions.filter((session) => session.status === 'running').length;
+    const pending = run.sessions.filter((session) => session.status === 'pending').length;
+    const total = run.sessions.length;
+    return {
+        title: buildRunProgressTitle(run, { completed, failed, running, total }),
+        metadata: {
+            runId: run.id,
+            status: run.status,
+            progress: `${completed}/${total} completed`,
+            active: running,
+            pending,
+            failed,
+            sessions: run.sessions.map(formatSessionActivity),
+        },
+    };
+}
+function buildRunProgressTitle(run, counts) {
+    const suffix = `(${counts.completed}/${counts.total} complete` +
+        (counts.running > 0 ? `, ${counts.running} active` : '') +
+        (counts.failed > 0 ? `, ${counts.failed} failed` : '') +
+        ')';
+    if (run.status === 'completed') {
+        return `Claude manager completed ${suffix}`;
+    }
+    if (run.status === 'failed') {
+        return `Claude manager failed ${suffix}`;
+    }
+    if (counts.running > 0) {
+        return `Claude manager running ${suffix}`;
+    }
+    return `Claude manager queued ${suffix}`;
+}
+function formatSessionActivity(session) {
+    const parts = [session.title, session.status];
+    if (session.claudeSessionId) {
+        parts.push(session.claudeSessionId);
+    }
+    const latestEvent = findLatestDisplayEvent(session.events);
+    if (session.finalText) {
+        parts.push(truncateForDisplay(session.finalText, 120));
+    }
+    else if (session.error) {
+        parts.push(truncateForDisplay(session.error, 120));
+    }
+    else if (latestEvent) {
+        parts.push(`${latestEvent.type}: ${truncateForDisplay(latestEvent.text, 120)}`);
+    }
+    return parts.join(' | ');
+}
+function findLatestDisplayEvent(events) {
+    const reversedEvents = [...events].reverse();
+    const preferredEvent = reversedEvents.find((event) => (event.type === 'result' ||
+        event.type === 'error' ||
+        event.type === 'assistant') &&
+        Boolean(event.text.trim()));
+    if (preferredEvent) {
+        return preferredEvent;
+    }
+    return [...events]
+        .reverse()
+        .find((event) => event.type !== 'partial' && Boolean(event.text.trim()));
+}
+function truncateForDisplay(text, maxLength) {
+    const normalized = text.replace(/\s+/g, ' ').trim();
+    if (normalized.length <= maxLength) {
+        return normalized;
+    }
+    return `${normalized.slice(0, maxLength - 3)}...`;
+}
+function summarizeSessionOutputs(sessions) {
+    return sessions
+        .map((session) => `${session.title}: ${resolveSessionOutput(session)}`)
+        .join('\n');
+}
+function resolveSessionOutput(session) {
+    const latestEvent = findLatestDisplayEvent(session.events);
+    return (session.finalText?.trim() ||
+        session.error?.trim() ||
+        latestEvent?.text.trim() ||
+        session.status);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doingdev/opencode-claude-manager-plugin",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "OpenCode plugin that orchestrates Claude Code sessions.",
   "keywords": [
     "opencode",
@@ -30,7 +30,8 @@
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "lint": "eslint .",
     "format": "prettier --write .",
-    "test": "vitest run"
+    "test": "vitest run",
+    "release": "npm run build && npm version patch && npm publish"
   },
   "engines": {
     "node": ">=22.0.0"