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

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,
@@ -284,13 +283,27 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                 },
             }),
             git_diff: tool({
-                description: 'Run git diff to see all current changes (staged + unstaged) relative to HEAD.',
+                description: 'Show diff of uncommitted changes. ' +
+                    'Use paths to filter to specific files/dirs. ' +
+                    'Use staged=true to see staged changes. ' +
+                    'Use ref to compare against a branch/tag/commit (e.g., ref="main").',
                 args: {
-                    cwd: tool.schema.string().optional(),
+                    paths: tool.schema.string().array().optional(),
+                    staged: tool.schema.boolean().optional(),
+                    ref: tool.schema.string().optional(),
                 },
-                async execute(_args, context) {
-                    annotateToolRun(context, 'Running git diff', {});
-                    const result = await services.manager.gitDiff();
+                async execute(args, context) {
+                    annotateToolRun(context, 'Running git diff', {
+                        paths: args.paths,
+                        staged: args.staged,
+                        ref: args.ref,
+                    });
+                    const paths = args.paths?.filter((p) => p !== undefined);
+                    const result = await services.manager.gitDiff({
+                        paths,
+                        staged: args.staged,
+                        ref: args.ref,
+                    });
                     return JSON.stringify(result, null, 2);
                 },
             }),
@@ -298,7 +311,6 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                 description: 'Stage all changes and commit with the given message.',
                 args: {
                     message: tool.schema.string().min(1),
-                    cwd: tool.schema.string().optional(),
                 },
                 async execute(args, context) {
                     annotateToolRun(context, 'Committing changes', {
@@ -309,19 +321,39 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                 },
             }),
             git_reset: tool({
-                description: 'Run git reset --hard HEAD and git clean -fd to discard ALL uncommitted changes and untracked files.',
-                args: {
-                    cwd: tool.schema.string().optional(),
-                },
+                description: 'Discard all uncommitted changes: runs git reset --hard HEAD and git clean -fd.',
+                args: {},
                 async execute(_args, context) {
                     annotateToolRun(context, 'Resetting working directory', {});
                     const result = await services.manager.gitReset();
                     return JSON.stringify(result, null, 2);
                 },
             }),
-            engineer_clear: tool({
-                description: 'Clear the active Claude Code session. The next send will start a fresh session. ' +
-                    'Use when context is full, the session is confused, or starting a different task.',
+            git_status: tool({
+                description: 'Show working tree status — lists changed files in short format. ' +
+                    'Returns isClean=true if nothing changed.',
+                args: {},
+                async execute(_args, context) {
+                    annotateToolRun(context, 'Checking git status', {});
+                    const result = await services.manager.gitStatus();
+                    return JSON.stringify(result, null, 2);
+                },
+            }),
+            git_log: tool({
+                description: 'Show recent commits in short format. ' +
+                    'Default shows last 5 commits. Use count to change.',
+                args: {
+                    count: tool.schema.number().optional(),
+                },
+                async execute(args, context) {
+                    annotateToolRun(context, 'Fetching git log', { count: args.count });
+                    const result = await services.manager.gitLog(args.count ?? 5);
+                    return result;
+                },
+            }),
+            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 +366,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 +383,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 +406,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 +513,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 +526,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 +549,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

@@ -90,9 +90,11 @@ export const managerPromptRegistry = {
         'After each delegation:',
         '1. git_diff — read the FULL diff. Check for unintended changes, missing tests,',
         '   style violations.',
-        '2. If correct: spawn `engineer_build` to run tests/lint/typecheck.',
-        '3. If tests pass: git_commit to checkpoint.',
-        '4. If wrong: spawn `engineer_build` with a specific correction.',
+        '2. git_status — check what files changed (quick overview)',
+        '3. git_log -n 5 — see recent commits (understand context)',
+        '4. If correct: spawn `engineer_build` to run tests/lint/typecheck.',
+        '5. If tests pass: git_commit to checkpoint.',
+        '6. If wrong: spawn `engineer_build` with a specific correction.',
         '   On second failure: git_reset and rewrite the prompt from scratch.',
         '   Never send three corrections for the same problem.',
         '',
@@ -116,7 +118,9 @@ export const managerPromptRegistry = {
         '## Tools reference',
         'todowrite / todoread — track multi-step work',
         'question             — ask the user structured questions with options',
-        'git_diff             — review all uncommitted changes',
+        'git_diff             — review changes (filter with paths, staged, ref args)',
+        'git_status           — quick overview of changed files',
+        'git_log              — recent commits (default: last 5)',
         'git_commit           — stage all + commit',
         'git_reset            — hard reset + clean (destructive)',
         'approval_policy      — view tool approval rules',
@@ -148,13 +152,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 +195,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/dist/src/claude/claude-agent-sdk-adapter.d.ts

@@ -0,0 +1,27 @@
+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';
+import type { ToolApprovalManager } from './tool-approval-manager.js';
+export type ClaudeSessionEventHandler = (event: ClaudeSessionEvent) => void | Promise<void>;
+interface ClaudeAgentSdkFacade {
+    query(params: {
+        prompt: string;
+        options?: Options;
+    }): Query;
+    listSessions(options?: {
+        dir?: string;
+    }): Promise<SDKSessionInfo[]>;
+    getSessionMessages(sessionId: string, options?: {
+        dir?: string;
+    }): Promise<SessionMessage[]>;
+}
+export declare class ClaudeAgentSdkAdapter {
+    private readonly sdkFacade;
+    private readonly approvalManager?;
+    constructor(sdkFacade?: ClaudeAgentSdkFacade, approvalManager?: ToolApprovalManager | undefined);
+    runSession(input: RunClaudeSessionInput, onEvent?: ClaudeSessionEventHandler): Promise<ClaudeSessionRunResult>;
+    listSavedSessions(cwd?: string): Promise<ClaudeSessionSummary[]>;
+    getTranscript(sessionId: string, cwd?: string): Promise<ClaudeSessionTranscriptMessage[]>;
+    probeCapabilities(cwd: string, settingSources?: SettingSource[]): Promise<ClaudeCapabilitySnapshot>;
+    private buildOptions;
+}
+export {};