@doingdev/opencode-claude-manager-plugin 0.1.34 → 0.1.35

package/README.md

@@ -53,15 +53,15 @@ If you are testing locally, point OpenCode at the local package or plugin file u
 
 ### Engineer session
 
-- `engineer_send` — send a message to the persistent Claude Code session. Auto-creates on first call, resumes on subsequent calls.
+- `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.
-  - `mode` — `"plan"` (read-only investigation) or `"free"` (default, normal execution with edits).
   - `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).
-- `engineer_compact` — compress the active session context while preserving session state. Use before clearing when context is high but salvageable.
-- `engineer_clear` — drop the active session entirely; next send starts fresh.
-- `engineer_status` — get current session health: context %, turns, cost, session ID.
+- `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.
 
 ### Git operations
 
@@ -71,9 +71,8 @@ If you are testing locally, point OpenCode at the local package or plugin file u
 
 ### Inspection
 
-- `engineer_metadata` — inspect available Claude commands, skills, hooks, and settings.
-- `engineer_sessions` — list Claude sessions or inspect a saved transcript.
-- `engineer_runs` — list or inspect persisted manager run records (may be empty if tasks were sent directly via `engineer_send` rather than the run-tracking path).
+- `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.
 
 ### Tool approval
 
@@ -86,7 +85,7 @@ If you are testing locally, point OpenCode at the local package or plugin file u
 The plugin registers a CTO → Manager → Engineer hierarchy 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 (`engineer_*`, `git_*`, `approval_*`) plus read/search/web tools for investigation.
+- **`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.
 
 These are added to OpenCode config at runtime by the plugin, so they do not require separate manual `opencode.json` entries.
@@ -95,27 +94,27 @@ These are added to OpenCode config at runtime by the plugin, so they do not requ
 
 Typical flow inside OpenCode:
 
-1. Inspect Claude capabilities with `engineer_metadata`.
-2. Delegate work with `engineer_send`.
+1. Explore the codebase with `explore`.
+2. Implement changes with `implement`.
 3. Review changes with `git_diff`, then commit or reset.
-4. Inspect saved Claude history with `engineer_sessions` or prior orchestration records with `engineer_runs`.
+4. Inspect saved Claude history with `list_transcripts` or prior orchestration records with `list_history`.
 
 Example tasks:
 
 ```text
-Use engineer_send to implement the new validation logic in src/auth.ts, then review with git_diff.
+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 engineer_send with freshSession:true to investigate the failing CI test in test/api.test.ts using mode:"plan".
+Use explore with freshSession:true to investigate the failing CI test in test/api.test.ts.
 ```
 
 Reclaim context mid-session:
 
 ```text
-Use engineer_compact to free up context, then continue with the next implementation step.
+Use compact_context to free up context, then continue with the next implementation step.
 ```
 
 ## Local Development

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

@@ -409,7 +409,7 @@ function truncateJsonish(value, max) {
         return truncateString(JSON.stringify(value), max);
     }
     catch {
-        return truncateString(String(value), max);
+        return truncateString('[non-serializable]', max);
     }
 }
 function truncateString(s, max) {

package/dist/claude/session-live-tailer.js

@@ -99,7 +99,7 @@ export class SessionLiveTailer {
                 });
                 let chunk = '';
                 stream.on('data', (data) => {
-                    chunk += data;
+                    chunk += typeof data === 'string' ? data : data.toString('utf8');
                 });
                 stream.on('end', () => {
                     reading = false;
@@ -264,6 +264,6 @@ function stringifyContent(value) {
         return JSON.stringify(value);
     }
     catch {
-        return String(value);
+        return '[non-serializable]';
     }
 }

package/dist/plugin/agent-hierarchy.d.ts

@@ -11,7 +11,7 @@ export declare const AGENT_CTO = "cto";
 export declare const AGENT_ENGINEER_PLAN = "engineer_plan";
 export declare const AGENT_ENGINEER_BUILD = "engineer_build";
 /** All restricted tool IDs (union of all domain groups) */
-export declare const ALL_RESTRICTED_TOOL_IDS: readonly ["engineer_send", "engineer_send_plan", "engineer_send_build", "engineer_compact", "engineer_clear", "engineer_status", "engineer_sessions", "engineer_runs", "git_diff", "git_commit", "git_reset", "approval_policy", "approval_decisions", "approval_update"];
+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", "approval_policy", "approval_decisions", "approval_update"];
 type ToolPermission = 'allow' | 'ask' | 'deny';
 type AgentPermission = {
     '*'?: ToolPermission;

package/dist/plugin/agent-hierarchy.js

@@ -17,23 +17,18 @@ export const AGENT_ENGINEER_BUILD = 'engineer_build';
 // ---------------------------------------------------------------------------
 /** Shared engineer session tools (compact, clear, status, diagnostics) */
 const ENGINEER_SHARED_TOOL_IDS = [
-    'engineer_compact',
-    'engineer_clear',
-    'engineer_status',
-    'engineer_sessions',
-    'engineer_runs',
-];
-/** All engineer tools — generic send + mode-locked sends + shared session tools */
-const ENGINEER_TOOL_IDS = [
-    'engineer_send',
-    'engineer_send_plan',
-    'engineer_send_build',
-    ...ENGINEER_SHARED_TOOL_IDS,
+    'compact_context',
+    'clear_session',
+    'session_health',
+    'list_transcripts',
+    'list_history',
 ];
+/** All engineer tools — mode-locked sends + shared session tools */
+const ENGINEER_TOOL_IDS = ['explore', 'implement', ...ENGINEER_SHARED_TOOL_IDS];
 /** Tools for the engineer_plan wrapper (plan-mode send + shared) */
-const ENGINEER_PLAN_TOOL_IDS = ['engineer_send_plan', ...ENGINEER_SHARED_TOOL_IDS];
+const ENGINEER_PLAN_TOOL_IDS = ['explore', ...ENGINEER_SHARED_TOOL_IDS];
 /** Tools for the engineer_build wrapper (build-mode send + shared) */
-const ENGINEER_BUILD_TOOL_IDS = ['engineer_send_build', ...ENGINEER_SHARED_TOOL_IDS];
+const ENGINEER_BUILD_TOOL_IDS = ['implement', ...ENGINEER_SHARED_TOOL_IDS];
 /** Git tools — owned by CTO */
 const GIT_TOOL_IDS = ['git_diff', 'git_commit', 'git_reset'];
 /** Approval tools — owned by CTO */
@@ -87,7 +82,7 @@ function buildCtoPermissions() {
         },
     };
 }
-/** Engineer plan wrapper: read-only investigation + engineer_send_plan + shared session tools. */
+/** Engineer plan wrapper: read-only investigation + explore + shared session tools. */
 function buildEngineerPlanPermissions() {
     const denied = {};
     for (const toolId of ALL_RESTRICTED_TOOL_IDS) {
@@ -104,7 +99,7 @@ function buildEngineerPlanPermissions() {
         ...allowed,
     };
 }
-/** Engineer build wrapper: read-only investigation + engineer_send_build + shared session tools. */
+/** Engineer build wrapper: read-only investigation + implement + shared session tools. */
 function buildEngineerBuildPermissions() {
     const denied = {};
     for (const toolId of ALL_RESTRICTED_TOOL_IDS) {

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

@@ -5,7 +5,7 @@ import { AGENT_CTO, AGENT_ENGINEER_BUILD, AGENT_ENGINEER_PLAN, buildCtoAgentConf
 import { getOrCreatePluginServices } from './service-factory.js';
 export const ClaudeManagerPlugin = async ({ worktree }) => {
     const services = getOrCreatePluginServices(worktree);
-    async function executeEngineerSend(args, context) {
+    async function executeDelegate(args, context) {
         const cwd = args.cwd ?? context.worktree;
         if (args.freshSession) {
             await services.manager.clearSession(cwd);
@@ -13,8 +13,11 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
         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...',
+            title: hasActiveSession
+                ? '⚡ Claude Code: Resuming session...'
+                : '⚡ Claude Code: Initializing...',
             metadata: {
+                status: 'running',
                 sessionId: services.manager.getStatus().sessionId,
                 prompt: promptPreview,
             },
@@ -49,8 +52,9 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     // ignore parse errors
                 }
                 context.metadata({
-                    title: `Claude Code: Running ${toolName}...${usageSuffix}`,
+                    title: `⚡ Claude Code: Running ${toolName}...${usageSuffix}`,
                     metadata: {
+                        status: 'running',
                         sessionId: event.sessionId,
                         type: event.type,
                         tool: toolName,
@@ -61,8 +65,9 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
             else if (event.type === 'assistant') {
                 const thinkingPreview = event.text.length > 150 ? event.text.slice(0, 150) + '...' : event.text;
                 context.metadata({
-                    title: `Claude Code: Thinking...${usageSuffix}`,
+                    title: `⚡ Claude Code: Thinking...${usageSuffix}`,
                     metadata: {
+                        status: 'running',
                         sessionId: event.sessionId,
                         type: event.type,
                         thinking: thinkingPreview,
@@ -71,8 +76,9 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
             }
             else if (event.type === 'init') {
                 context.metadata({
-                    title: `Claude Code: Session started`,
+                    title: `⚡ Claude Code: Session started`,
                     metadata: {
+                        status: 'running',
                         sessionId: event.sessionId,
                         prompt: promptPreview,
                     },
@@ -80,9 +86,11 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
             }
             else if (event.type === 'user') {
                 const preview = event.text.length > 200 ? event.text.slice(0, 200) + '...' : event.text;
+                const outputPreview = formatToolOutputPreview(event.text);
                 context.metadata({
-                    title: `Claude Code: Tool result${usageSuffix}`,
+                    title: `⚡ Claude Code: ${outputPreview}${usageSuffix}`,
                     metadata: {
+                        status: 'running',
                         sessionId: event.sessionId,
                         type: event.type,
                         output: preview,
@@ -92,17 +100,25 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
             else if (event.type === 'tool_progress') {
                 let toolName = 'tool';
                 let elapsed = 0;
+                let progressCurrent;
+                let progressTotal;
                 try {
                     const parsed = JSON.parse(event.text);
                     toolName = parsed.name ?? 'tool';
                     elapsed = parsed.elapsed ?? 0;
+                    progressCurrent = parsed.current;
+                    progressTotal = parsed.total;
                 }
                 catch {
                     // ignore
                 }
+                const progressInfo = progressCurrent !== undefined && progressTotal !== undefined
+                    ? ` [${progressCurrent}/${progressTotal}]`
+                    : '';
                 context.metadata({
-                    title: `Claude Code: ${toolName} running ${elapsed > 0 ? `(${elapsed.toFixed(0)}s)` : ''}...${usageSuffix}`,
+                    title: `⚡ Claude Code: ${toolName} running ${elapsed > 0 ? `(${elapsed.toFixed(0)}s)` : ''}${progressInfo}...${usageSuffix}`,
                     metadata: {
+                        status: 'running',
                         sessionId: event.sessionId,
                         type: event.type,
                         tool: toolName,
@@ -113,8 +129,9 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
             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${usageSuffix}`,
+                    title: `✅ Claude Code: Tool done${usageSuffix}`,
                     metadata: {
+                        status: 'success',
                         sessionId: event.sessionId,
                         type: event.type,
                         summary,
@@ -124,8 +141,9 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
             else if (event.type === 'partial') {
                 const delta = event.text.length > 200 ? event.text.slice(0, 200) + '...' : event.text;
                 context.metadata({
-                    title: `Claude Code: Writing...${usageSuffix}`,
+                    title: `⚡ Claude Code: Writing...${usageSuffix}`,
                     metadata: {
+                        status: 'running',
                         sessionId: event.sessionId,
                         type: event.type,
                         delta,
@@ -134,12 +152,14 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
             }
             else if (event.type === 'error') {
                 context.metadata({
-                    title: `Claude Code: Error`,
+                    title: `❌ Claude Code: Error`,
                     metadata: {
+                        status: 'error',
                         sessionId: event.sessionId,
                         error: event.text.slice(0, 200),
                     },
                 });
+                showToastIfAvailable(context, `Claude Code error: ${event.text.slice(0, 100)}`);
             }
         });
         const costLabel = `$${(result.totalCostUsd ?? 0).toFixed(4)}`;
@@ -147,15 +167,17 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
         const contextWarning = formatContextWarning(result.context);
         if (contextWarning) {
             context.metadata({
-                title: `Claude Code: Context at ${result.context.estimatedContextPercent}% (${turns} turns)`,
-                metadata: { sessionId: result.sessionId, contextWarning },
+                title: `⚠️ Claude Code: Context at ${result.context.estimatedContextPercent}% (${turns} turns)`,
+                metadata: { status: 'warning', sessionId: result.sessionId, contextWarning },
             });
+            showToastIfAvailable(context, `⚠️ Context usage at ${result.context.estimatedContextPercent}% — consider compacting`);
         }
         else {
             context.metadata({
-                title: `Claude Code: Complete (${turns} turns, ${costLabel})`,
-                metadata: { sessionId: result.sessionId },
+                title: `✅ Claude Code: Complete (${turns} turns, ${costLabel})`,
+                metadata: { status: 'success', sessionId: result.sessionId },
             });
+            showToastIfAvailable(context, `✅ Session complete (${turns} turns, ${costLabel})`);
         }
         let toolOutputs = [];
         if (result.sessionId) {
@@ -196,29 +218,26 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
             config.agent[AGENT_ENGINEER_BUILD] ??= buildEngineerBuildAgentConfig(derivedPrompts);
         },
         tool: {
-            engineer_send: tool({
-                description: 'Send a message to the persistent Claude Code session with explicit mode control. ' +
-                    'Most agents should use engineer_send_plan or engineer_send_build instead.',
+            explore: tool({
+                description: 'Investigate and analyze code without making edits. ' +
+                    'Read-only exploration of the codebase. ' +
+                    'Preferred first step before implementation.',
                 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) {
-                    return executeEngineerSend(args, context);
+                    return executeDelegate({ ...args, mode: 'plan' }, context);
                 },
             }),
-            engineer_send_plan: tool({
-                description: 'Preferred path for repo exploration and investigation. ' +
-                    'Send a read-only investigation message to the Claude Code session in plan mode. ' +
-                    'The engineer will analyze code without making edits. ' +
-                    'Auto-creates a session on first call. Resumes the existing session on subsequent calls. ' +
-                    'Returns the assistant response and current context health snapshot.',
+            implement: tool({
+                description: 'Implement code changes - can read, edit, and create files. ' +
+                    'Use after exploration to make changes.',
                 args: {
                     message: tool.schema.string().min(1),
                     model: tool.schema
@@ -229,35 +248,12 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     cwd: tool.schema.string().optional(),
                 },
                 async execute(args, context) {
-                    return executeEngineerSend({ ...args, mode: 'plan' }, context);
+                    return executeDelegate({ ...args, mode: 'free' }, context);
                 },
             }),
-            engineer_send_build: tool({
-                description: 'Preferred path for implementation after framing. ' +
-                    'Send an implementation message to the Claude Code session in free mode. ' +
-                    'The engineer can read, edit, and create files. ' +
-                    'Auto-creates a session on first call. Resumes the existing session on subsequent calls. ' +
-                    'Returns the assistant response and current context health snapshot. ' +
-                    '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'),
-                    freshSession: tool.schema.boolean().default(false),
-                    cwd: tool.schema.string().optional(),
-                },
-                async execute(args, context) {
-                    return executeEngineerSend({ ...args, mode: 'free' }, context);
-                },
-            }),
-            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.',
+            compact_context: tool({
+                description: 'Compress session history to reclaim context window space. ' +
+                    'Preserves state while reducing token usage.',
                 args: {
                     cwd: tool.schema.string().optional(),
                 },
@@ -269,9 +265,12 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     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 },
+                            ? `⚠️ Claude Code: Compacted — context at ${snap.estimatedContextPercent}%`
+                            : `✅ Claude Code: Compacted (${snap.totalTurns} turns, $${(snap.totalCostUsd ?? 0).toFixed(4)})`,
+                        metadata: {
+                            status: contextWarning ? 'warning' : 'success',
+                            sessionId: result.sessionId,
+                        },
                     });
                     return JSON.stringify({
                         sessionId: result.sessionId,
@@ -319,9 +318,9 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     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.',
+            clear_session: tool({
+                description: 'Clear the active session to start fresh. ' +
+                    'Use when context is full or starting a new task.',
                 args: {
                     cwd: tool.schema.string().optional(),
                     reason: tool.schema.string().optional(),
@@ -334,8 +333,8 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     return JSON.stringify({ clearedSessionId: clearedId });
                 },
             }),
-            engineer_status: tool({
-                description: 'Get the current persistent session status: context usage %, turns, cost, active session ID.',
+            session_health: tool({
+                description: 'Check session health metrics: context usage %, turn count, cost, and session ID.',
                 args: {
                     cwd: tool.schema.string().optional(),
                 },
@@ -351,9 +350,8 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     }, 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.',
+            list_transcripts: tool({
+                description: 'List available session transcripts or inspect a specific transcript by ID.',
                 args: {
                     cwd: tool.schema.string().optional(),
                     sessionId: tool.schema.string().optional(),
@@ -375,8 +373,8 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     return JSON.stringify(sessions, null, 2);
                 },
             }),
-            engineer_runs: tool({
-                description: 'List persistent manager run records.',
+            list_history: tool({
+                description: 'List persistent run records from the manager or inspect a specific run.',
                 args: {
                     cwd: tool.schema.string().optional(),
                     runId: tool.schema.string().optional(),
@@ -482,8 +480,12 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
         },
     };
 };
-function annotateToolRun(context, title, metadata) {
-    context.metadata({ title, metadata });
+function annotateToolRun(context, title, metadata, status) {
+    const emoji = status ? `${formatStatusEmoji(status)} ` : '';
+    context.metadata({
+        title: `${emoji}${title}`,
+        metadata: { ...metadata, ...(status ? { status } : {}) },
+    });
 }
 function formatLiveUsage(turns, cost) {
     if (turns === undefined && cost === undefined) {
@@ -491,10 +493,10 @@ function formatLiveUsage(turns, cost) {
     }
     const parts = [];
     if (turns !== undefined) {
-        parts.push(`${turns} turns`);
+        parts.push(`🔄 ${turns} turns`);
     }
     if (cost !== undefined) {
-        parts.push(`$${cost.toFixed(4)}`);
+        parts.push(`💰 $${cost.toFixed(4)}`);
     }
     return ` (${parts.join(', ')})`;
 }
@@ -514,3 +516,47 @@ function formatContextWarning(context) {
         .replace('{turns}', String(totalTurns))
         .replace('{cost}', totalCostUsd.toFixed(2));
 }
+function formatStatusEmoji(status) {
+    switch (status) {
+        case 'running':
+            return '⚡';
+        case 'success':
+            return '✅';
+        case 'error':
+            return '❌';
+        case 'warning':
+            return '⚠️';
+    }
+}
+function formatToolOutputPreview(text) {
+    const lower = text.toLowerCase();
+    let prefix;
+    if (lower.includes('"tool":"read"') ||
+        lower.includes('"name":"read"') ||
+        lower.includes('file contents')) {
+        prefix = '↳ Read: ';
+    }
+    else if (lower.includes('"tool":"grep"') ||
+        lower.includes('"name":"grep"') ||
+        lower.includes('matches found')) {
+        prefix = '↳ Found: ';
+    }
+    else if (lower.includes('"tool":"write"') ||
+        lower.includes('"name":"write"') ||
+        lower.includes('"tool":"edit"') ||
+        lower.includes('"name":"edit"') ||
+        lower.includes('file written') ||
+        lower.includes('file updated')) {
+        prefix = '↳ Wrote: ';
+    }
+    else {
+        prefix = '↳ Result: ';
+    }
+    const snippet = text.replace(/\s+/g, ' ').trim();
+    const truncated = snippet.length > 60 ? snippet.slice(0, 60) + '...' : snippet;
+    return `${prefix}${truncated}`;
+}
+function showToastIfAvailable(context, message) {
+    const ctx = context;
+    ctx.client?.tui?.showToast?.(message);
+}

package/dist/prompts/registry.js

@@ -148,13 +148,13 @@ export const managerPromptRegistry = {
         '- Do NOT implement changes yourself — investigation only.',
         '',
         '## Behavior',
-        '- Send the objective to the engineer using engineer_send_plan.',
+        '- Send the objective to the engineer using explore.',
         "- Return the engineer's response verbatim. Do not summarize.",
-        '- Use freshSession:true on engineer_send_plan when the task is unrelated to prior work.',
+        '- Use freshSession:true on explore when the task is unrelated to prior work.',
         '',
         '## Context management',
-        '- Check engineer_status before sending.',
-        '- Under 50%: proceed. Over 70%: engineer_compact. Over 85%: engineer_clear.',
+        '- Check session_health before sending.',
+        '- Under 50%: proceed. Over 70%: compact_context. Over 85%: clear_session.',
         '',
         '## Model selection',
         '- claude-opus-4-6 + high: complex analysis (default).',
@@ -191,13 +191,13 @@ export const managerPromptRegistry = {
         '- Do NOT implement changes yourself — investigation only.',
         '',
         '## Behavior',
-        '- Send the objective to the engineer using engineer_send_build.',
+        '- Send the objective to the engineer using implement.',
         "- Return the engineer's response verbatim. Do not summarize.",
-        '- Use freshSession:true on engineer_send_build when the task is unrelated to prior work.',
+        '- Use freshSession:true on implement when the task is unrelated to prior work.',
         '',
         '## Context management',
-        '- Check engineer_status before sending.',
-        '- Under 50%: proceed. Over 70%: engineer_compact. Over 85%: engineer_clear.',
+        '- Check session_health before sending.',
+        '- Under 50%: proceed. Over 70%: compact_context. Over 85%: clear_session.',
         '',
         '## Model selection',
         '- claude-opus-4-6 + high: most coding tasks (default).',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doingdev/opencode-claude-manager-plugin",
-  "version": "0.1.34",
+  "version": "0.1.35",
   "description": "OpenCode plugin that orchestrates Claude Code sessions.",
   "keywords": [
     "opencode",

package/dist/metadata/claude-metadata.service.d.ts

@@ -1,12 +0,0 @@
-import type { ClaudeMetadataSnapshot, ClaudeSettingSource } from '../types/contracts.js';
-import type { ClaudeAgentSdkAdapter } from '../claude/claude-agent-sdk-adapter.js';
-import type { RepoClaudeConfigReader } from './repo-claude-config-reader.js';
-export declare class ClaudeMetadataService {
-    private readonly configReader;
-    private readonly sdkAdapter;
-    constructor(configReader: RepoClaudeConfigReader, sdkAdapter: ClaudeAgentSdkAdapter);
-    collect(cwd: string, options?: {
-        includeSdkProbe?: boolean;
-        settingSources?: ClaudeSettingSource[];
-    }): Promise<ClaudeMetadataSnapshot>;
-}

package/dist/metadata/claude-metadata.service.js

@@ -1,38 +0,0 @@
-export class ClaudeMetadataService {
-    configReader;
-    sdkAdapter;
-    constructor(configReader, sdkAdapter) {
-        this.configReader = configReader;
-        this.sdkAdapter = sdkAdapter;
-    }
-    async collect(cwd, options = {}) {
-        const baseSnapshot = await this.configReader.read(cwd);
-        if (!options.includeSdkProbe) {
-            return dedupeSnapshot(baseSnapshot);
-        }
-        const capabilities = await this.sdkAdapter.probeCapabilities(cwd, options.settingSources);
-        return dedupeSnapshot({
-            ...baseSnapshot,
-            commands: [...baseSnapshot.commands, ...capabilities.commands],
-            agents: capabilities.agents,
-        });
-    }
-}
-function dedupeSnapshot(snapshot) {
-    return {
-        ...snapshot,
-        commands: dedupeByName(snapshot.commands),
-        skills: dedupeByName(snapshot.skills),
-        hooks: dedupeByName(snapshot.hooks),
-        agents: dedupeByName(snapshot.agents),
-    };
-}
-function dedupeByName(items) {
-    const seen = new Map();
-    for (const item of items) {
-        if (!seen.has(item.name)) {
-            seen.set(item.name, item);
-        }
-    }
-    return [...seen.values()].sort((left, right) => left.name.localeCompare(right.name));
-}

package/dist/metadata/repo-claude-config-reader.d.ts

@@ -1,7 +0,0 @@
-import type { ClaudeMetadataSnapshot } from '../types/contracts.js';
-export declare class RepoClaudeConfigReader {
-    read(cwd: string): Promise<ClaudeMetadataSnapshot>;
-    private readSkills;
-    private readCommands;
-    private readSettings;
-}

package/dist/metadata/repo-claude-config-reader.js

@@ -1,154 +0,0 @@
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-import JSON5 from 'json5';
-export class RepoClaudeConfigReader {
-    async read(cwd) {
-        const claudeDirectory = path.join(cwd, '.claude');
-        const skillsDirectory = path.join(claudeDirectory, 'skills');
-        const commandsDirectory = path.join(claudeDirectory, 'commands');
-        const claudeMdCandidates = [
-            path.join(cwd, 'CLAUDE.md'),
-            path.join(claudeDirectory, 'CLAUDE.md'),
-        ];
-        const collectedAt = new Date().toISOString();
-        const [skills, commands, settingsResult, claudeMdPath] = await Promise.all([
-            this.readSkills(skillsDirectory),
-            this.readCommands(commandsDirectory),
-            this.readSettings(claudeDirectory),
-            findFirstExistingPath(claudeMdCandidates),
-        ]);
-        return {
-            collectedAt,
-            cwd,
-            commands: [...skillsToCommands(skills), ...commands],
-            skills,
-            hooks: settingsResult.hooks,
-            agents: [],
-            claudeMdPath: claudeMdPath ?? undefined,
-            settingsPaths: settingsResult.settingsPaths,
-        };
-    }
-    async readSkills(directory) {
-        if (!(await pathExists(directory))) {
-            return [];
-        }
-        const entries = await fs.readdir(directory, { withFileTypes: true });
-        const skills = await Promise.all(entries
-            .filter((entry) => entry.isDirectory())
-            .map(async (entry) => {
-            const skillPath = path.join(directory, entry.name, 'SKILL.md');
-            if (!(await pathExists(skillPath))) {
-                return null;
-            }
-            const content = await fs.readFile(skillPath, 'utf8');
-            return {
-                name: entry.name,
-                description: extractMarkdownDescription(content),
-                path: skillPath,
-                source: 'skill',
-            };
-        }));
-        return skills.filter((skill) => skill !== null);
-    }
-    async readCommands(directory) {
-        if (!(await pathExists(directory))) {
-            return [];
-        }
-        const commandFiles = await collectMarkdownFiles(directory);
-        const commands = await Promise.all(commandFiles.map(async (commandPath) => {
-            const content = await fs.readFile(commandPath, 'utf8');
-            return {
-                name: path.basename(commandPath, path.extname(commandPath)),
-                description: extractMarkdownDescription(content),
-                source: 'command',
-                path: commandPath,
-            };
-        }));
-        return commands.sort((left, right) => left.name.localeCompare(right.name));
-    }
-    async readSettings(claudeDirectory) {
-        const candidatePaths = [
-            path.join(claudeDirectory, 'settings.json'),
-            path.join(claudeDirectory, 'settings.local.json'),
-        ];
-        const settingsPaths = [];
-        const hooks = [];
-        for (const candidatePath of candidatePaths) {
-            if (!(await pathExists(candidatePath))) {
-                continue;
-            }
-            settingsPaths.push(candidatePath);
-            const content = await fs.readFile(candidatePath, 'utf8');
-            const parsed = JSON5.parse(content);
-            const hookEntries = Object.entries(parsed.hooks ?? {});
-            for (const [hookName, hookValue] of hookEntries) {
-                const hookMatchers = Array.isArray(hookValue) ? hookValue : [hookValue];
-                for (const hookMatcher of hookMatchers) {
-                    if (!hookMatcher || typeof hookMatcher !== 'object') {
-                        continue;
-                    }
-                    const matcher = typeof hookMatcher.matcher === 'string'
-                        ? hookMatcher.matcher
-                        : undefined;
-                    const commandCount = Array.isArray(hookMatcher.hooks)
-                        ? (hookMatcher.hooks?.length ?? 0)
-                        : 0;
-                    hooks.push({
-                        name: hookName,
-                        matcher,
-                        sourcePath: candidatePath,
-                        commandCount,
-                    });
-                }
-            }
-        }
-        return {
-            settingsPaths,
-            hooks,
-        };
-    }
-}
-function extractMarkdownDescription(markdown) {
-    const lines = markdown
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .filter(Boolean);
-    const descriptionLine = lines.find((line) => !line.startsWith('#') && !line.startsWith('---'));
-    return descriptionLine ?? 'No description provided.';
-}
-async function collectMarkdownFiles(directory) {
-    const entries = await fs.readdir(directory, { withFileTypes: true });
-    const files = await Promise.all(entries.map(async (entry) => {
-        const resolvedPath = path.join(directory, entry.name);
-        if (entry.isDirectory()) {
-            return collectMarkdownFiles(resolvedPath);
-        }
-        return entry.name.endsWith('.md') ? [resolvedPath] : [];
-    }));
-    return files.flat();
-}
-async function pathExists(candidatePath) {
-    try {
-        await fs.access(candidatePath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function findFirstExistingPath(candidatePaths) {
-    for (const candidatePath of candidatePaths) {
-        if (await pathExists(candidatePath)) {
-            return candidatePath;
-        }
-    }
-    return null;
-}
-function skillsToCommands(skills) {
-    return skills.map((skill) => ({
-        name: skill.name,
-        description: skill.description,
-        source: 'skill',
-        path: skill.path,
-    }));
-}

package/dist/plugin/orchestrator.plugin.d.ts

@@ -1,2 +0,0 @@
-import type { Plugin } from '@opencode-ai/plugin';
-export declare const OrchestratorPlugin: Plugin;

package/dist/plugin/orchestrator.plugin.js

@@ -1,116 +0,0 @@
-import { prompts } from '../prompts/registry.js';
-import { evaluateBashCommand, extractBashCommand, } from '../safety/bash-safety.js';
-/**
- * Thin OpenCode orchestrator plugin with Claude Code specialist subagents.
- *
- * - Registers `claude-code` provider via a local shim over ai-sdk-provider-claude-code.
- * - Creates one orchestrator agent (uses the user's default OpenCode model).
- * - Creates 4 Claude Code subagents: planning + build × opus + sonnet.
- * - Enforces bash safety via the permission.ask hook.
- *
- * NOTE: Claude Code `effort` is not configurable through OpenCode provider/model
- * options at this time. The subagent prompts compensate by setting high-quality
- * expectations directly.
- */
-// Resolve the shim path at module load time so it is stable for the lifetime
-// of the process. The compiled output for this file sits at dist/plugin/ and
-// the shim at dist/providers/, so we walk up one level.
-const claudeCodeShimUrl = new URL('../providers/claude-code-wrapper.js', import.meta.url).href;
-export const OrchestratorPlugin = async () => {
-    return {
-        config: async (config) => {
-            config.provider ??= {};
-            config.agent ??= {};
-            // ── Provider ──────────────────────────────────────────────────────
-            // Uses a file:// shim so OpenCode's factory-finder heuristic sees only
-            // createClaudeCode and not createAPICallError from the upstream package.
-            config.provider['claude-code'] ??= {
-                npm: claudeCodeShimUrl,
-                models: {
-                    opus: {
-                        id: 'opus',
-                        name: 'Claude Code Opus 4.6',
-                    },
-                    sonnet: {
-                        id: 'sonnet',
-                        name: 'Claude Code Sonnet 4.6',
-                    },
-                },
-            };
-            // ── Orchestrator (uses user's default model — no model set) ───────
-            config.agent['opencode-orchestrator'] ??= {
-                description: 'CTO-level orchestrator that gathers context and delegates coding to Claude Code specialists.',
-                mode: 'primary',
-                color: '#D97757',
-                prompt: prompts.orchestrator,
-                permission: {
-                    '*': 'deny',
-                    read: 'allow',
-                    grep: 'allow',
-                    glob: 'allow',
-                    list: 'allow',
-                    webfetch: 'allow',
-                    question: 'allow',
-                    todowrite: 'allow',
-                    todoread: 'allow',
-                    task: 'allow',
-                    bash: 'deny',
-                    edit: 'deny',
-                    skill: 'deny',
-                },
-            };
-            // ── 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 = {
-                '*': 'deny',
-            };
-            config.agent['claude-code-planning-opus'] ??= {
-                description: 'Claude Code Opus specialist for investigation, architecture, and planning.',
-                model: 'claude-code/opus',
-                mode: 'subagent',
-                color: 'info',
-                prompt: prompts.planningAgent,
-                permission: { ...claudeCodePermissions },
-            };
-            config.agent['claude-code-planning-sonnet'] ??= {
-                description: 'Claude Code Sonnet specialist for lighter investigation and planning.',
-                model: 'claude-code/sonnet',
-                mode: 'subagent',
-                color: 'info',
-                prompt: prompts.planningAgent,
-                permission: { ...claudeCodePermissions },
-            };
-            // ── Build subagents ───────────────────────────────────────────────
-            config.agent['claude-code-build-opus'] ??= {
-                description: 'Claude Code Opus specialist for implementation and validation.',
-                model: 'claude-code/opus',
-                mode: 'subagent',
-                color: 'success',
-                prompt: prompts.buildAgent,
-                permission: { ...claudeCodePermissions },
-            };
-            config.agent['claude-code-build-sonnet'] ??= {
-                description: 'Claude Code Sonnet specialist for lighter implementation tasks.',
-                model: 'claude-code/sonnet',
-                mode: 'subagent',
-                color: 'success',
-                prompt: prompts.buildAgent,
-                permission: { ...claudeCodePermissions },
-            };
-        },
-        // ── Bash safety via permission.ask hook ────────────────────────────
-        // Handles both v1 Permission ({ type, pattern }) and v2 PermissionRequest
-        // ({ permission, patterns }) via runtime narrowing in extractBashCommand.
-        'permission.ask': async (input, output) => {
-            const command = extractBashCommand(input);
-            if (command === null)
-                return;
-            const result = evaluateBashCommand(command);
-            if (!result.allowed) {
-                output.status = 'deny';
-            }
-        },
-    };
-};

package/dist/providers/claude-code-wrapper.d.ts

@@ -1,13 +0,0 @@
-/**
- * Thin re-export shim for ai-sdk-provider-claude-code.
- *
- * OpenCode's provider loader finds the provider factory by scanning
- * `Object.keys(module).find(key => key.startsWith("create"))`. The upstream
- * package exports `createAPICallError` before `createClaudeCode`, so OpenCode
- * picks the wrong function and `.languageModel` ends up undefined.
- *
- * This shim re-exports only `createClaudeCode`, making it the sole "create*"
- * export. The plugin references this file via a `file://` URL so the upstream
- * package is still the actual implementation.
- */
-export { createClaudeCode } from 'ai-sdk-provider-claude-code';

package/dist/providers/claude-code-wrapper.js

@@ -1,13 +0,0 @@
-/**
- * Thin re-export shim for ai-sdk-provider-claude-code.
- *
- * OpenCode's provider loader finds the provider factory by scanning
- * `Object.keys(module).find(key => key.startsWith("create"))`. The upstream
- * package exports `createAPICallError` before `createClaudeCode`, so OpenCode
- * picks the wrong function and `.languageModel` ends up undefined.
- *
- * This shim re-exports only `createClaudeCode`, making it the sole "create*"
- * export. The plugin references this file via a `file://` URL so the upstream
- * package is still the actual implementation.
- */
-export { createClaudeCode } from 'ai-sdk-provider-claude-code';

package/dist/safety/bash-safety.d.ts

@@ -1,21 +0,0 @@
-/**
- * Minimal bash command safety layer.
- * Denies known-dangerous patterns; allows everything else.
- */
-export type BashSafetyResult = {
-    allowed: true;
-} | {
-    allowed: false;
-    reason: string;
-};
-export declare function evaluateBashCommand(command: string): BashSafetyResult;
-/**
- * Extract the bash command string from a permission hook input,
- * handling both SDK payload shapes:
- *
- *   v1 Permission:       { type: string, pattern?: string | string[], metadata }
- *   v2 PermissionRequest: { permission: string, patterns: string[], metadata }
- *
- * Returns `null` when the input is not a bash permission request.
- */
-export declare function extractBashCommand(input: Record<string, unknown>): string | null;

package/dist/safety/bash-safety.js

@@ -1,62 +0,0 @@
-/**
- * Minimal bash command safety layer.
- * Denies known-dangerous patterns; allows everything else.
- */
-const DENY_PATTERNS = [
-    { pattern: 'rm -rf /', reason: 'Destructive: rm -rf / is not allowed.' },
-    {
-        pattern: 'git push --force',
-        reason: 'Force push is not allowed.',
-    },
-    {
-        pattern: 'git reset --hard',
-        reason: 'git reset --hard is not allowed. Use a safer alternative.',
-    },
-];
-export function evaluateBashCommand(command) {
-    for (const { pattern, reason } of DENY_PATTERNS) {
-        if (command.includes(pattern)) {
-            return { allowed: false, reason };
-        }
-    }
-    return { allowed: true };
-}
-/**
- * Extract the bash command string from a permission hook input,
- * handling both SDK payload shapes:
- *
- *   v1 Permission:       { type: string, pattern?: string | string[], metadata }
- *   v2 PermissionRequest: { permission: string, patterns: string[], metadata }
- *
- * Returns `null` when the input is not a bash permission request.
- */
-export function extractBashCommand(input) {
-    // Determine the permission kind from whichever field is present.
-    const kind = typeof input['permission'] === 'string'
-        ? input['permission']
-        : typeof input['type'] === 'string'
-            ? input['type']
-            : null;
-    if (kind !== 'bash')
-        return null;
-    // Prefer an explicit command in metadata regardless of shape.
-    const meta = input['metadata'];
-    if (meta !== null && typeof meta === 'object' && !Array.isArray(meta)) {
-        const cmd = meta['command'];
-        if (typeof cmd === 'string' && cmd.length > 0)
-            return cmd;
-    }
-    // v2: patterns is always string[]
-    const patterns = input['patterns'];
-    if (Array.isArray(patterns) && patterns.length > 0) {
-        return patterns.join(' ');
-    }
-    // v1: pattern may be string or string[]
-    const pattern = input['pattern'];
-    if (typeof pattern === 'string' && pattern.length > 0)
-        return pattern;
-    if (Array.isArray(pattern) && pattern.length > 0) {
-        return pattern.join(' ');
-    }
-    return null;
-}