@doingdev/opencode-claude-manager-plugin 0.1.29 → 0.1.31

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

@@ -19,9 +19,7 @@ function mergeSkillIntoAllowedTools(allowedTools, disallowedTools) {
     if (allowedTools === undefined) {
         return ['Skill'];
     }
-    return allowedTools.includes('Skill')
-        ? allowedTools
-        : [...allowedTools, 'Skill'];
+    return allowedTools.includes('Skill') ? allowedTools : [...allowedTools, 'Skill'];
 }
 export class ClaudeAgentSdkAdapter {
     sdkFacade;
@@ -262,11 +260,8 @@ function normalizeSdkMessages(message, includePartials) {
         return normalizeUserSdkMessage(message, sessionId);
     }
     if (message.type === 'tool_progress') {
-        const toolName = 'tool_name' in message && typeof message.tool_name === 'string'
-            ? message.tool_name
-            : 'tool';
-        const elapsed = 'elapsed_time_seconds' in message &&
-            typeof message.elapsed_time_seconds === 'number'
+        const toolName = 'tool_name' in message && typeof message.tool_name === 'string' ? message.tool_name : 'tool';
+        const elapsed = 'elapsed_time_seconds' in message && typeof message.elapsed_time_seconds === 'number'
             ? message.elapsed_time_seconds
             : 0;
         return [
@@ -279,9 +274,7 @@ function normalizeSdkMessages(message, includePartials) {
         ];
     }
     if (message.type === 'tool_use_summary') {
-        const summary = 'summary' in message && typeof message.summary === 'string'
-            ? message.summary
-            : '';
+        const summary = 'summary' in message && typeof message.summary === 'string' ? message.summary : '';
         return [
             {
                 type: 'tool_summary',
@@ -359,9 +352,7 @@ function normalizeUserSdkMessage(message, sessionId) {
     if (message.tool_use_result !== undefined) {
         const extra = truncateJsonish(message.tool_use_result, 1500);
         if (extra) {
-            payload = payload
-                ? `${payload}\n[tool_use_result] ${extra}`
-                : `[tool_use_result] ${extra}`;
+            payload = payload ? `${payload}\n[tool_use_result] ${extra}` : `[tool_use_result] ${extra}`;
         }
     }
     payload = truncateString(payload, USER_MESSAGE_MAX);
@@ -439,8 +430,7 @@ function extractPartialEventText(event) {
         if (typeof delta.text === 'string' && delta.text.length > 0) {
             return delta.text;
         }
-        if (typeof delta.partial_json === 'string' &&
-            delta.partial_json.length > 0) {
+        if (typeof delta.partial_json === 'string' && delta.partial_json.length > 0) {
             return delta.partial_json;
         }
     }
@@ -462,8 +452,7 @@ function extractText(payload) {
             if (typeof contentPart.text === 'string') {
                 return contentPart.text;
             }
-            if (contentPart.type === 'tool_use' &&
-                typeof contentPart.name === 'string') {
+            if (contentPart.type === 'tool_use' && typeof contentPart.name === 'string') {
                 return `[tool:${contentPart.name}]`;
             }
             return '';

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

@@ -1,15 +1,10 @@
-import type { ClaudeCapabilitySnapshot, ClaudeMetadataSnapshot, ClaudeSessionRunResult, ClaudeSessionSummary, ClaudeSessionTranscriptMessage, RunClaudeSessionInput } from '../types/contracts.js';
-import type { ClaudeMetadataService } from '../metadata/claude-metadata.service.js';
+import type { ClaudeCapabilitySnapshot, ClaudeSessionRunResult, ClaudeSessionSummary, ClaudeSessionTranscriptMessage, RunClaudeSessionInput } from '../types/contracts.js';
 import type { ClaudeAgentSdkAdapter, ClaudeSessionEventHandler } from './claude-agent-sdk-adapter.js';
 export declare class ClaudeSessionService {
     private readonly sdkAdapter;
-    private readonly metadataService;
-    constructor(sdkAdapter: ClaudeAgentSdkAdapter, metadataService: ClaudeMetadataService);
+    constructor(sdkAdapter: ClaudeAgentSdkAdapter);
     runTask(input: RunClaudeSessionInput, onEvent?: ClaudeSessionEventHandler): Promise<ClaudeSessionRunResult>;
     listSessions(cwd?: string): Promise<ClaudeSessionSummary[]>;
     getTranscript(sessionId: string, cwd?: string): Promise<ClaudeSessionTranscriptMessage[]>;
-    inspectRepository(cwd: string, options?: {
-        includeSdkProbe?: boolean;
-    }): Promise<ClaudeMetadataSnapshot>;
     probeCapabilities(cwd: string): Promise<ClaudeCapabilitySnapshot>;
 }

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

@@ -1,9 +1,7 @@
 export class ClaudeSessionService {
     sdkAdapter;
-    metadataService;
-    constructor(sdkAdapter, metadataService) {
+    constructor(sdkAdapter) {
         this.sdkAdapter = sdkAdapter;
-        this.metadataService = metadataService;
     }
     runTask(input, onEvent) {
         return this.sdkAdapter.runSession(input, onEvent);
@@ -14,9 +12,6 @@ export class ClaudeSessionService {
     getTranscript(sessionId, cwd) {
         return this.sdkAdapter.getTranscript(sessionId, cwd);
     }
-    inspectRepository(cwd, options) {
-        return this.metadataService.collect(cwd, options);
-    }
     probeCapabilities(cwd) {
         return this.sdkAdapter.probeCapabilities(cwd);
     }

package/dist/claude/tool-approval-manager.js

@@ -137,9 +137,7 @@ export class ToolApprovalManager {
         const matchedRule = this.findMatchingRule(toolName, inputJson);
         const action = matchedRule?.action ?? this.policy.defaultAction;
         const denyMessage = action === 'deny'
-            ? (matchedRule?.denyMessage ??
-                this.policy.defaultDenyMessage ??
-                'Denied by policy.')
+            ? (matchedRule?.denyMessage ?? this.policy.defaultDenyMessage ?? 'Denied by policy.')
             : undefined;
         this.recordDecision({
             timestamp: new Date().toISOString(),
@@ -174,9 +172,7 @@ export class ToolApprovalManager {
         this.policy = { ...policy, rules: [...policy.rules] };
     }
     addRule(rule, position) {
-        if (position !== undefined &&
-            position >= 0 &&
-            position < this.policy.rules.length) {
+        if (position !== undefined && position >= 0 && position < this.policy.rules.length) {
             this.policy.rules.splice(position, 0, rule);
         }
         else {
@@ -223,9 +219,7 @@ function matchesToolPattern(pattern, toolName) {
     if (!pattern.includes('*')) {
         return pattern === toolName;
     }
-    const regex = new RegExp('^' +
-        pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*') +
-        '$');
+    const regex = new RegExp('^' + pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*') + '$');
     return regex.test(toolName);
 }
 function safeJsonStringify(value) {

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import type { Plugin } from '@opencode-ai/plugin';
 import { ClaudeManagerPlugin } from './plugin/claude-manager.plugin.js';
-export type { ClaudeCapabilitySnapshot, ClaudeMetadataSnapshot, ClaudeSessionRunResult, ClaudeSessionSummary, ClaudeSessionTranscriptMessage, ManagerPromptRegistry, RunClaudeSessionInput, SessionContextSnapshot, GitDiffResult, GitOperationResult, PersistentRunRecord, PersistentRunResult, ActiveSessionState, ContextWarningLevel, SessionMode, LiveTailEvent, ToolOutputPreview, ToolApprovalRule, ToolApprovalPolicy, ToolApprovalDecision, } from './types/contracts.js';
+export type { ClaudeCapabilitySnapshot, ClaudeSessionRunResult, ClaudeSessionSummary, ClaudeSessionTranscriptMessage, ManagerPromptRegistry, RunClaudeSessionInput, SessionContextSnapshot, GitDiffResult, GitOperationResult, PersistentRunRecord, PersistentRunResult, ActiveSessionState, ContextWarningLevel, SessionMode, LiveTailEvent, ToolOutputPreview, ToolApprovalRule, ToolApprovalPolicy, ToolApprovalDecision, } from './types/contracts.js';
 export { SessionLiveTailer } from './claude/session-live-tailer.js';
 export { ClaudeManagerPlugin };
 export declare const plugin: Plugin;

package/dist/manager/context-tracker.js

@@ -19,8 +19,7 @@ export class ContextTracker {
         }
         if (result.inputTokens !== undefined) {
             // If input tokens dropped significantly, compaction likely occurred
-            if (this.latestInputTokens !== null &&
-                result.inputTokens < this.latestInputTokens * 0.5) {
+            if (this.latestInputTokens !== null && result.inputTokens < this.latestInputTokens * 0.5) {
                 this.compactionCount++;
             }
             this.latestInputTokens = result.inputTokens;
@@ -85,8 +84,7 @@ export class ContextTracker {
         return null;
     }
     isAboveTokenThreshold(thresholdTokens = 200_000) {
-        return (this.latestInputTokens !== null &&
-            this.latestInputTokens >= thresholdTokens);
+        return this.latestInputTokens !== null && this.latestInputTokens >= thresholdTokens;
     }
     reset() {
         this.totalTurns = 0;

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_compact", "engineer_clear", "engineer_status", "engineer_metadata", "engineer_sessions", "engineer_runs", "git_diff", "git_commit", "git_reset", "approval_policy", "approval_decisions", "approval_update"];
+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"];
 type ToolPermission = 'allow' | 'ask' | 'deny';
 type AgentPermission = {
     '*'?: ToolPermission;

package/dist/plugin/agent-hierarchy.js

@@ -15,24 +15,29 @@ export const AGENT_ENGINEER_BUILD = 'engineer_build';
 // ---------------------------------------------------------------------------
 // Tool IDs — grouped by domain
 // ---------------------------------------------------------------------------
-/** All engineer tools — session interaction + diagnostics. Owned by wrappers. */
-const ENGINEER_TOOL_IDS = [
-    'engineer_send',
+/** Shared engineer session tools (compact, clear, status, diagnostics) */
+const ENGINEER_SHARED_TOOL_IDS = [
     'engineer_compact',
     'engineer_clear',
     'engineer_status',
-    'engineer_metadata',
     '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,
+];
+/** Tools for the engineer_plan wrapper (plan-mode send + shared) */
+const ENGINEER_PLAN_TOOL_IDS = ['engineer_send_plan', ...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];
 /** Git tools — owned by CTO */
 const GIT_TOOL_IDS = ['git_diff', 'git_commit', 'git_reset'];
 /** Approval tools — owned by CTO */
-const APPROVAL_TOOL_IDS = [
-    'approval_policy',
-    'approval_decisions',
-    'approval_update',
-];
+const APPROVAL_TOOL_IDS = ['approval_policy', 'approval_decisions', 'approval_update'];
 /** All restricted tool IDs (union of all domain groups) */
 export const ALL_RESTRICTED_TOOL_IDS = [
     ...ENGINEER_TOOL_IDS,
@@ -82,14 +87,30 @@ function buildCtoPermissions() {
         },
     };
 }
-/** Engineer wrapper: all engineer tools. No read-only, git, or approval tools. */
-function buildEngineerWrapperPermissions() {
+/** Engineer plan wrapper: engineer_send_plan + shared session tools. */
+function buildEngineerPlanPermissions() {
+    const denied = {};
+    for (const toolId of ALL_RESTRICTED_TOOL_IDS) {
+        denied[toolId] = 'deny';
+    }
+    const allowed = {};
+    for (const toolId of ENGINEER_PLAN_TOOL_IDS) {
+        allowed[toolId] = 'allow';
+    }
+    return {
+        '*': 'deny',
+        ...denied,
+        ...allowed,
+    };
+}
+/** Engineer build wrapper: engineer_send_build + shared session tools. */
+function buildEngineerBuildPermissions() {
     const denied = {};
     for (const toolId of ALL_RESTRICTED_TOOL_IDS) {
         denied[toolId] = 'deny';
     }
     const allowed = {};
-    for (const toolId of ENGINEER_TOOL_IDS) {
+    for (const toolId of ENGINEER_BUILD_TOOL_IDS) {
         allowed[toolId] = 'allow';
     }
     return {
@@ -115,7 +136,7 @@ export function buildEngineerPlanAgentConfig(prompts) {
         description: 'Engineer that manages a Claude Code session in plan mode for read-only investigation and analysis.',
         mode: 'subagent',
         color: '#D97757',
-        permission: buildEngineerWrapperPermissions(),
+        permission: buildEngineerPlanPermissions(),
         prompt: prompts.engineerPlanPrompt,
     };
 }
@@ -124,7 +145,7 @@ export function buildEngineerBuildAgentConfig(prompts) {
         description: 'Engineer that manages a Claude Code session in free mode for implementation and execution.',
         mode: 'subagent',
         color: '#D97757',
-        permission: buildEngineerWrapperPermissions(),
+        permission: buildEngineerBuildPermissions(),
         prompt: prompts.engineerBuildPrompt,
     };
 }

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

@@ -4,6 +4,177 @@ 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) {
+        const cwd = args.cwd ?? context.worktree;
+        if (args.freshSession) {
+            await services.manager.clearSession(cwd);
+        }
+        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...',
+            metadata: {
+                sessionId: services.manager.getStatus().sessionId,
+                prompt: promptPreview,
+            },
+        });
+        let turnsSoFar = 0;
+        let costSoFar = 0;
+        const result = await services.manager.sendMessage(cwd, args.message, {
+            model: args.model,
+            effort: args.effort,
+            mode: args.mode,
+            abortSignal: context.abort,
+        }, (event) => {
+            if (event.turns !== undefined) {
+                turnsSoFar = event.turns;
+            }
+            if (event.totalCostUsd !== undefined) {
+                costSoFar = event.totalCostUsd;
+            }
+            const costLabel = `$${costSoFar.toFixed(4)}`;
+            if (event.type === 'tool_call') {
+                let toolName = 'tool';
+                let inputPreview = '';
+                try {
+                    const parsed = JSON.parse(event.text);
+                    toolName = parsed.name ?? 'tool';
+                    if (parsed.input) {
+                        const inputStr = typeof parsed.input === 'string' ? parsed.input : JSON.stringify(parsed.input);
+                        inputPreview = inputStr.length > 150 ? inputStr.slice(0, 150) + '...' : inputStr;
+                    }
+                }
+                catch {
+                    // ignore parse errors
+                }
+                context.metadata({
+                    title: `Claude Code: Running ${toolName}... (${turnsSoFar} turns, ${costLabel})`,
+                    metadata: {
+                        sessionId: event.sessionId,
+                        type: event.type,
+                        tool: toolName,
+                        input: inputPreview,
+                    },
+                });
+            }
+            else if (event.type === 'assistant') {
+                const thinkingPreview = event.text.length > 150 ? event.text.slice(0, 150) + '...' : event.text;
+                context.metadata({
+                    title: `Claude Code: Thinking... (${turnsSoFar} turns, ${costLabel})`,
+                    metadata: {
+                        sessionId: event.sessionId,
+                        type: event.type,
+                        thinking: thinkingPreview,
+                    },
+                });
+            }
+            else if (event.type === 'init') {
+                context.metadata({
+                    title: `Claude Code: Session started`,
+                    metadata: {
+                        sessionId: event.sessionId,
+                        prompt: promptPreview,
+                    },
+                });
+            }
+            else if (event.type === 'user') {
+                const preview = event.text.length > 200 ? event.text.slice(0, 200) + '...' : event.text;
+                context.metadata({
+                    title: `Claude Code: Tool result (${turnsSoFar} turns, ${costLabel})`,
+                    metadata: {
+                        sessionId: event.sessionId,
+                        type: event.type,
+                        output: preview,
+                    },
+                });
+            }
+            else if (event.type === 'tool_progress') {
+                let toolName = 'tool';
+                let elapsed = 0;
+                try {
+                    const parsed = JSON.parse(event.text);
+                    toolName = parsed.name ?? 'tool';
+                    elapsed = parsed.elapsed ?? 0;
+                }
+                catch {
+                    // ignore
+                }
+                context.metadata({
+                    title: `Claude Code: ${toolName} running ${elapsed > 0 ? `(${elapsed.toFixed(0)}s)` : ''}... (${turnsSoFar} turns, ${costLabel})`,
+                    metadata: {
+                        sessionId: event.sessionId,
+                        type: event.type,
+                        tool: toolName,
+                        elapsed,
+                    },
+                });
+            }
+            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 (${turnsSoFar} turns, ${costLabel})`,
+                    metadata: {
+                        sessionId: event.sessionId,
+                        type: event.type,
+                        summary,
+                    },
+                });
+            }
+            else if (event.type === 'partial') {
+                const delta = event.text.length > 200 ? event.text.slice(0, 200) + '...' : event.text;
+                context.metadata({
+                    title: `Claude Code: Writing... (${turnsSoFar} turns, ${costLabel})`,
+                    metadata: {
+                        sessionId: event.sessionId,
+                        type: event.type,
+                        delta,
+                    },
+                });
+            }
+            else if (event.type === 'error') {
+                context.metadata({
+                    title: `Claude Code: Error`,
+                    metadata: {
+                        sessionId: event.sessionId,
+                        error: event.text.slice(0, 200),
+                    },
+                });
+            }
+        });
+        const costLabel = `$${(result.totalCostUsd ?? 0).toFixed(4)}`;
+        const turns = result.turns ?? 0;
+        const contextWarning = formatContextWarning(result.context);
+        if (contextWarning) {
+            context.metadata({
+                title: `Claude Code: Context at ${result.context.estimatedContextPercent}% (${turns} turns)`,
+                metadata: { sessionId: result.sessionId, contextWarning },
+            });
+        }
+        else {
+            context.metadata({
+                title: `Claude Code: Complete (${turns} turns, ${costLabel})`,
+                metadata: { sessionId: result.sessionId },
+            });
+        }
+        let toolOutputs = [];
+        if (result.sessionId) {
+            try {
+                toolOutputs = await services.liveTailer.getToolOutputPreview(result.sessionId, cwd, 3);
+            }
+            catch {
+                // Non-critical — the JSONL file may not exist yet.
+            }
+        }
+        return JSON.stringify({
+            sessionId: result.sessionId,
+            finalText: result.finalText,
+            turns: result.turns,
+            totalCostUsd: result.totalCostUsd,
+            context: result.context,
+            contextWarning,
+            toolOutputs: toolOutputs.length > 0 ? toolOutputs : undefined,
+        }, null, 2);
+    }
     return {
         config: async (config) => {
             config.agent ??= {};
@@ -15,12 +186,45 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
         },
         tool: {
             engineer_send: tool({
-                description: 'Send a message to the persistent Claude Code session. ' +
+                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.',
+                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);
+                },
+            }),
+            engineer_send_plan: tool({
+                description: '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.',
+                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: 'plan' }, context);
+                },
+            }),
+            engineer_send_build: tool({
+                description: '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. ' +
-                    'Use mode "plan" for read-only investigation and planning (no edits), ' +
-                    'or "free" (default) for normal execution with edit permissions. ' +
-                    'Set freshSession to clear the active session before sending (use for unrelated tasks). ' +
                     '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: {
@@ -28,201 +232,12 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     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'),
+                    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) {
-                    const cwd = args.cwd ?? context.worktree;
-                    if (args.freshSession) {
-                        await services.manager.clearSession(cwd);
-                    }
-                    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...',
-                        metadata: {
-                            sessionId: services.manager.getStatus().sessionId,
-                            prompt: promptPreview,
-                        },
-                    });
-                    let turnsSoFar = 0;
-                    let costSoFar = 0;
-                    const result = await services.manager.sendMessage(cwd, args.message, {
-                        model: args.model,
-                        effort: args.effort,
-                        mode: args.mode,
-                        abortSignal: context.abort,
-                    }, (event) => {
-                        if (event.turns !== undefined) {
-                            turnsSoFar = event.turns;
-                        }
-                        if (event.totalCostUsd !== undefined) {
-                            costSoFar = event.totalCostUsd;
-                        }
-                        const costLabel = `$${costSoFar.toFixed(4)}`;
-                        if (event.type === 'tool_call') {
-                            let toolName = 'tool';
-                            let inputPreview = '';
-                            try {
-                                const parsed = JSON.parse(event.text);
-                                toolName = parsed.name ?? 'tool';
-                                if (parsed.input) {
-                                    const inputStr = typeof parsed.input === 'string'
-                                        ? parsed.input
-                                        : JSON.stringify(parsed.input);
-                                    inputPreview =
-                                        inputStr.length > 150
-                                            ? inputStr.slice(0, 150) + '...'
-                                            : inputStr;
-                                }
-                            }
-                            catch {
-                                // ignore parse errors
-                            }
-                            context.metadata({
-                                title: `Claude Code: Running ${toolName}... (${turnsSoFar} turns, ${costLabel})`,
-                                metadata: {
-                                    sessionId: event.sessionId,
-                                    type: event.type,
-                                    tool: toolName,
-                                    input: inputPreview,
-                                },
-                            });
-                        }
-                        else if (event.type === 'assistant') {
-                            const thinkingPreview = event.text.length > 150
-                                ? event.text.slice(0, 150) + '...'
-                                : event.text;
-                            context.metadata({
-                                title: `Claude Code: Thinking... (${turnsSoFar} turns, ${costLabel})`,
-                                metadata: {
-                                    sessionId: event.sessionId,
-                                    type: event.type,
-                                    thinking: thinkingPreview,
-                                },
-                            });
-                        }
-                        else if (event.type === 'init') {
-                            context.metadata({
-                                title: `Claude Code: Session started`,
-                                metadata: {
-                                    sessionId: event.sessionId,
-                                    prompt: promptPreview,
-                                },
-                            });
-                        }
-                        else if (event.type === 'user') {
-                            const preview = event.text.length > 200
-                                ? event.text.slice(0, 200) + '...'
-                                : event.text;
-                            context.metadata({
-                                title: `Claude Code: Tool result (${turnsSoFar} turns, ${costLabel})`,
-                                metadata: {
-                                    sessionId: event.sessionId,
-                                    type: event.type,
-                                    output: preview,
-                                },
-                            });
-                        }
-                        else if (event.type === 'tool_progress') {
-                            let toolName = 'tool';
-                            let elapsed = 0;
-                            try {
-                                const parsed = JSON.parse(event.text);
-                                toolName = parsed.name ?? 'tool';
-                                elapsed = parsed.elapsed ?? 0;
-                            }
-                            catch {
-                                // ignore
-                            }
-                            context.metadata({
-                                title: `Claude Code: ${toolName} running ${elapsed > 0 ? `(${elapsed.toFixed(0)}s)` : ''}... (${turnsSoFar} turns, ${costLabel})`,
-                                metadata: {
-                                    sessionId: event.sessionId,
-                                    type: event.type,
-                                    tool: toolName,
-                                    elapsed,
-                                },
-                            });
-                        }
-                        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 (${turnsSoFar} turns, ${costLabel})`,
-                                metadata: {
-                                    sessionId: event.sessionId,
-                                    type: event.type,
-                                    summary,
-                                },
-                            });
-                        }
-                        else if (event.type === 'partial') {
-                            const delta = event.text.length > 200
-                                ? event.text.slice(0, 200) + '...'
-                                : event.text;
-                            context.metadata({
-                                title: `Claude Code: Writing... (${turnsSoFar} turns, ${costLabel})`,
-                                metadata: {
-                                    sessionId: event.sessionId,
-                                    type: event.type,
-                                    delta,
-                                },
-                            });
-                        }
-                        else if (event.type === 'error') {
-                            context.metadata({
-                                title: `Claude Code: Error`,
-                                metadata: {
-                                    sessionId: event.sessionId,
-                                    error: event.text.slice(0, 200),
-                                },
-                            });
-                        }
-                    });
-                    const costLabel = `$${(result.totalCostUsd ?? 0).toFixed(4)}`;
-                    const turns = result.turns ?? 0;
-                    const contextWarning = formatContextWarning(result.context);
-                    if (contextWarning) {
-                        context.metadata({
-                            title: `Claude Code: Context at ${result.context.estimatedContextPercent}% (${turns} turns)`,
-                            metadata: { sessionId: result.sessionId, contextWarning },
-                        });
-                    }
-                    else {
-                        context.metadata({
-                            title: `Claude Code: Complete (${turns} turns, ${costLabel})`,
-                            metadata: { sessionId: result.sessionId },
-                        });
-                    }
-                    // Fetch recent tool output from the JSONL file for richer feedback.
-                    let toolOutputs = [];
-                    if (result.sessionId) {
-                        try {
-                            toolOutputs = await services.liveTailer.getToolOutputPreview(result.sessionId, cwd, 3);
-                        }
-                        catch {
-                            // Non-critical — the JSONL file may not exist yet.
-                        }
-                    }
-                    return JSON.stringify({
-                        sessionId: result.sessionId,
-                        finalText: result.finalText,
-                        turns: result.turns,
-                        totalCostUsd: result.totalCostUsd,
-                        context: result.context,
-                        contextWarning,
-                        toolOutputs: toolOutputs.length > 0 ? toolOutputs : undefined,
-                    }, null, 2);
+                    return executeEngineerSend({ ...args, mode: 'free' }, context);
                 },
             }),
             engineer_compact: tool({
@@ -323,22 +338,6 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     }, null, 2);
                 },
             }),
-            engineer_metadata: tool({
-                description: 'Inspect Claude slash commands, skills, hooks, and repo settings.',
-                args: {
-                    cwd: tool.schema.string().optional(),
-                    includeSdkProbe: tool.schema.boolean().default(false),
-                },
-                async execute(args, context) {
-                    annotateToolRun(context, 'Collecting Claude metadata', {
-                        includeSdkProbe: args.includeSdkProbe,
-                    });
-                    const metadata = await services.sessions.inspectRepository(args.cwd ?? context.worktree, {
-                        includeSdkProbe: args.includeSdkProbe,
-                    });
-                    return JSON.stringify(metadata, 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.',

package/dist/plugin/service-factory.js

@@ -2,8 +2,6 @@ import { ClaudeAgentSdkAdapter } from '../claude/claude-agent-sdk-adapter.js';
 import { ClaudeSessionService } from '../claude/claude-session.service.js';
 import { SessionLiveTailer } from '../claude/session-live-tailer.js';
 import { ToolApprovalManager } from '../claude/tool-approval-manager.js';
-import { ClaudeMetadataService } from '../metadata/claude-metadata.service.js';
-import { RepoClaudeConfigReader } from '../metadata/repo-claude-config-reader.js';
 import { FileRunStateStore } from '../state/file-run-state-store.js';
 import { TranscriptStore } from '../state/transcript-store.js';
 import { ContextTracker } from '../manager/context-tracker.js';
@@ -19,8 +17,7 @@ export function getOrCreatePluginServices(worktree) {
     }
     const approvalManager = new ToolApprovalManager();
     const sdkAdapter = new ClaudeAgentSdkAdapter(undefined, approvalManager);
-    const metadataService = new ClaudeMetadataService(new RepoClaudeConfigReader(), sdkAdapter);
-    const sessionService = new ClaudeSessionService(sdkAdapter, metadataService);
+    const sessionService = new ClaudeSessionService(sdkAdapter);
     const contextTracker = new ContextTracker();
     const sessionController = new SessionController(sdkAdapter, contextTracker, managerPromptRegistry.engineerSessionPrompt, managerPromptRegistry.modePrefixes);
     const gitOps = new GitOperations(worktree);

package/dist/prompts/registry.js

@@ -1,84 +1,76 @@
 export const managerPromptRegistry = {
     ctoSystemPrompt: [
-        'You are the CTO — a top 0.001% technical leader.',
-        'You never rush to code. You understand first, plan fully, then delegate.',
-        'Your engineers are excellent — your job is to point them at the right problem',
-        'with the right context so they succeed on the first try.',
-        '',
-        '## Workflow — always follow these phases in order',
-        '',
-        '### Phase 1: Understand',
-        'Before anything else, build a complete mental model:',
-        '- What is the user actually asking for? What problem are they solving?',
-        '- Read the relevant code yourself (read, grep, glob). Understand the current state.',
-        '- If the codebase is unfamiliar, spawn `engineer_plan` to explore broadly.',
-        '- If requirements are ambiguous, ask the user ONE specific question.',
-        '  Prefer the question tool when discrete options exist.',
-        '  Never block on multiple questions at once.',
-        '- Look for: existing patterns, naming conventions, test style, related code.',
-        '- Use webfetch / websearch if external context is needed (API docs, library usage).',
-        '',
-        '### Phase 2: Plan',
-        'Create a complete plan BEFORE delegating any work:',
-        '1. List every file that needs to change and why.',
-        '2. Identify the order of changes (dependencies between steps).',
-        '3. Note which steps can be parallelized.',
-        '4. Define the test/validation strategy for each step.',
-        '5. Anticipate risks: what could go wrong? What is the rollback path?',
-        '',
-        'Write the plan to the todo list using todowrite so progress is tracked.',
-        'Each item should be a concrete, delegatable unit of work.',
-        'Share the plan with the user before starting execution.',
-        '',
-        '### Phase 3: Execute',
-        'Delegate each plan step to engineers, one at a time:',
-        '1. Craft a precise instruction with all context the engineer needs:',
-        '   - Exact files, functions, and line numbers to change.',
-        '   - The current behavior and the desired behavior.',
-        '   - Relevant code snippets, patterns, and conventions to follow.',
-        '   - What tests to write or update.',
-        '   Bad:  "Fix the auth bug"',
-        '   Good: "In src/auth/session.ts, the `validateToken` function (line 42)',
-        '          throws on expired tokens instead of returning null. Change it to',
-        '          return null and update the caller in src/routes/login.ts:87.',
-        '          Follow the existing pattern in src/auth/refresh.ts:23.',
-        '          Update the test in test/auth.test.ts."',
-        '2. Spawn `engineer_build` with the instruction.',
-        '3. If steps are independent, spawn multiple engineers in parallel.',
-        '',
-        '### Phase 4: Review',
-        'After each delegation, verify the work:',
-        '1. git_diff — read the FULL diff, not just the summary.',
-        '2. Check for: unintended changes, missing tests, style violations, regressions.',
-        '3. If correct: spawn `engineer_build` to run tests/lint/typecheck.',
-        '4. If tests pass: git_commit to checkpoint. Update the todo list.',
-        '5. If wrong: spawn `engineer_build` with a specific correction.',
-        '   On second failure for the same issue: git_reset, then rewrite the prompt',
-        '   incorporating lessons from both failures.',
+        'You are a cracked AI-native engineer who uses Claude Code better than anyone.',
+        'You build the right thing, with the right quality, on the first try.',
+        '',
+        '## Core principle: verification-first',
+        'Every delegation MUST include how to verify success.',
+        'Tests, expected outputs, lint/typecheck commands, or before/after behavior.',
+        'This is the single highest-leverage thing you do.',
+        'Never delegate without telling the engineer how to prove it worked.',
+        '',
+        '## Right-size your approach',
+        'Not every task needs a plan. Assess complexity, then act:',
+        '',
+        '**Simple tasks** (typo, rename, add a log line, one-file fix):',
+        '  Skip investigation. Delegate directly with specific context.',
+        '',
+        '**Medium tasks** (bug fix, small feature, refactor one module):',
+        '  Read the relevant code yourself. Understand the current state.',
+        '  Then delegate with file paths, line numbers, patterns, and verification.',
+        '',
+        '**Complex tasks** (multi-file feature, architecture change, large refactor):',
+        '  1. Investigate: read code, grep for patterns, spawn `engineer_plan` to explore.',
+        '  2. If requirements are unclear, ask the user ONE specific question.',
+        '     Prefer the question tool when discrete options exist.',
+        '  3. Write a plan to the todo list (todowrite). Share it with the user.',
+        '  4. Execute steps sequentially, committing after each.',
+        '',
+        '## How to delegate effectively',
+        'The engineer does not have your context. Every instruction must be self-contained.',
+        'Include:',
+        '- Exact files, functions, and line numbers to change.',
+        '- Current behavior and desired behavior.',
+        '- Code snippets showing the pattern or convention to follow.',
+        '- How to verify: "Run `npm test`, expect all green." or',
+        '  "The function should return null instead of throwing."',
+        '',
+        'Bad:  "Fix the auth bug"',
+        'Good: "In src/auth/session.ts, `validateToken` (line 42) throws on expired',
+        '       tokens instead of returning null. Change it to return null.',
+        '       Update the caller in src/routes/login.ts:87.',
+        '       Follow the pattern in src/auth/refresh.ts:23.',
+        '       Run `npm test -- --grep auth` to verify. All tests should pass."',
+        '',
+        '## Review every change',
+        '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.',
+        '   On second failure: git_reset and rewrite the prompt from scratch.',
         '   Never send three corrections for the same problem.',
         '',
-        'Then return to Phase 3 for the next plan step.',
-        '',
         '## Engineers (via the Task tool)',
-        'You have two engineer types, invoke them with the Task tool:',
-        '- `engineer_plan` — read-only investigation and analysis.',
-        '  Use for: exploring code, mapping dependencies, understanding architecture.',
-        '- `engineer_build` — implementation and execution.',
-        '  Use for: all code changes, test runs, validation, and fixes.',
+        '- `engineer_plan` — read-only investigation. Use for: exploring unfamiliar code,',
+        '  mapping dependencies, analyzing impact, asking "how does X work?"',
+        '- `engineer_build` — implementation. Use for: all code changes, test runs, fixes.',
+        '- If steps are independent, spawn multiple engineers in parallel.',
         '',
-        'When delegating, include ALL relevant context in the instruction.',
-        'The engineer does not have your investigation history.',
-        'Paste file paths, line numbers, code snippets, and conventions directly.',
-        'Engineers manage their own sessions — you do not manage context or model selection.',
+        '## Context efficiency',
+        '- Use `engineer_plan` for broad exploration so your own context stays clean.',
+        '- When spawning engineers for unrelated tasks, tell them to use freshSession:true.',
+        '- Keep delegations focused — one concern per engineer invocation.',
         '',
         '## What you must NOT do',
-        '- Do NOT call any engineer_* tools directly. Use the Task tool to invoke engineers.',
+        '- Do NOT call any engineer_* tools directly. Use the Task tool.',
         '- Do NOT edit files or run bash commands yourself.',
-        '- Do NOT delegate before you have a plan.',
-        '- Do NOT skip the review phase.',
+        '- Do NOT skip review — always git_diff after delegation.',
+        '- Do NOT delegate without verification criteria.',
         '',
         '## Tools reference',
-        'todowrite / todoread — track your plan and mark progress',
+        'todowrite / todoread — track multi-step work',
         'question             — ask the user structured questions with options',
         'git_diff             — review all uncommitted changes',
         'git_commit           — stage all + commit',
@@ -95,113 +87,82 @@ export const managerPromptRegistry = {
         'State the blocker, what you need, and a concrete suggestion to unblock.',
     ].join('\n'),
     engineerPlanPrompt: [
-        'You manage a Claude Code engineer for read-only investigation and analysis.',
-        'You receive objectives from the CTO and operate the engineer session to fulfill them.',
+        'You manage a Claude Code engineer for read-only investigation.',
         '',
         '## Behavior',
-        '- Receive an objective from the CTO.',
-        '- Send it to the engineer using engineer_send with mode:"plan".',
-        "- Return the engineer's response verbatim. Do not summarize or interpret.",
+        '- Send the objective to the engineer using engineer_send_plan.',
+        "- Return the engineer's response verbatim. Do not summarize.",
+        '- Use freshSession:true on engineer_send_plan when the task is unrelated to prior work.',
         '',
         '## Context management',
-        'You own the engineer session lifecycle. Manage it carefully:',
-        '- Check engineer_status before sending to know the context health.',
-        '- Under 50%: proceed freely.',
-        '- 50–70%: finish the current task, then evaluate if compaction is needed.',
-        '- Over 70%: use engineer_compact to reclaim context space.',
-        '- Over 85%: use engineer_clear and start fresh.',
-        '- Use freshSession:true on engineer_send when starting an unrelated task.',
-        '',
-        '## Model and effort selection',
-        'Choose model and effort deliberately:',
-        '- claude-opus-4-6 + high effort: default for complex analysis.',
-        '- claude-sonnet-4-6 or claude-sonnet-4-5: lighter analysis tasks.',
-        '- effort "medium": acceptable for simple lookups or straightforward analysis.',
-        "- Do not use Haiku for this plugin's coding-agent role.",
-        '',
-        '## Diagnostics',
-        '- Use engineer_metadata to inspect repo Claude config when needed.',
-        '- Use engineer_sessions to review prior session transcripts.',
-        '- Use engineer_runs to review prior run records.',
+        '- Check engineer_status before sending.',
+        '- Under 50%: proceed. Over 70%: engineer_compact. Over 85%: engineer_clear.',
+        '',
+        '## Model selection',
+        '- claude-opus-4-6 + high: complex analysis (default).',
+        '- claude-sonnet-4-6: lighter analysis.',
+        '- effort "medium": simple lookups.',
         '',
         '## What you must NOT do',
         '- Do NOT investigate on your own — no read, grep, glob, or web tools.',
         '- Do NOT call git_*, approval_*, or any non-engineer tools.',
-        '- Do NOT add your own commentary or analysis to the engineer response.',
+        '- Do NOT add commentary to the engineer response.',
     ].join('\n'),
     engineerBuildPrompt: [
-        'You manage a Claude Code engineer for implementation and execution.',
-        'You receive objectives from the CTO and operate the engineer session to fulfill them.',
+        'You manage a Claude Code engineer for implementation.',
         '',
         '## Behavior',
-        '- Receive an objective from the CTO.',
-        '- Send it to the engineer using engineer_send with mode:"free".',
-        "- Return the engineer's response verbatim. Do not summarize or interpret.",
+        '- Send the objective to the engineer using engineer_send_build.',
+        "- Return the engineer's response verbatim. Do not summarize.",
+        '- Use freshSession:true on engineer_send_build when the task is unrelated to prior work.',
         '',
         '## Context management',
-        'You own the engineer session lifecycle. Manage it carefully:',
-        '- Check engineer_status before sending to know the context health.',
-        '- Under 50%: proceed freely.',
-        '- 50–70%: finish the current task, then evaluate if compaction is needed.',
-        '- Over 70%: use engineer_compact to reclaim context space.',
-        '- Over 85%: use engineer_clear and start fresh.',
-        '- Use freshSession:true on engineer_send when starting an unrelated task.',
-        '',
-        '## Model and effort selection',
-        'Choose model and effort deliberately:',
-        '- claude-opus-4-6 + high effort: default for most coding tasks.',
-        '- claude-sonnet-4-6 or claude-sonnet-4-5: faster/lighter work (simple renames,',
-        '  formatting, test scaffolding).',
-        '- effort "medium": acceptable for lighter tasks that do not require deep reasoning.',
-        '- effort "max": reserve for unusually hard problems (complex refactors,',
-        '  subtle concurrency bugs, large cross-cutting changes).',
-        "- Do not use Haiku for this plugin's coding-agent role.",
-        '',
-        '## Diagnostics',
-        '- Use engineer_metadata to inspect repo Claude config when needed.',
-        '- Use engineer_sessions to review prior session transcripts.',
-        '- Use engineer_runs to review prior run records.',
+        '- Check engineer_status before sending.',
+        '- Under 50%: proceed. Over 70%: engineer_compact. Over 85%: engineer_clear.',
+        '',
+        '## Model selection',
+        '- claude-opus-4-6 + high: most coding tasks (default).',
+        '- claude-sonnet-4-6: simple renames, formatting, scaffolding.',
+        '- effort "max": complex refactors, subtle bugs, cross-cutting changes.',
         '',
         '## What you must NOT do',
         '- Do NOT investigate on your own — no read, grep, glob, or web tools.',
         '- Do NOT call git_*, approval_*, or any non-engineer tools.',
-        '- Do NOT add your own commentary or analysis to the engineer response.',
+        '- Do NOT add commentary to the engineer response.',
     ].join('\n'),
     engineerSessionPrompt: [
-        'You are directed by the CTO acting as your technical lead.',
-        'Treat each message as a precise instruction from the CTO.',
+        'You are an expert engineer. Execute instructions precisely.',
         '',
-        '## Execution rules',
-        '- Execute instructions directly. Do not ask for clarification.',
-        '- Be concise — no preamble, no restating the task.',
+        '## Rules',
+        '- Execute directly. No preamble, no restating the task.',
         '- Prefer targeted file reads over reading entire files.',
-        '- Use the Agent tool for independent parallel work.',
-        '',
-        '## Quality expectations',
+        '- Use subagents for independent parallel work.',
         '- Follow existing repo conventions (naming, style, patterns).',
-        '- When creating or modifying code, consider edge cases and error handling.',
-        '- When modifying existing code, preserve surrounding style and structure.',
-        '- If asked to implement a feature, include relevant tests unless told otherwise.',
-        '- Run tests/lint/typecheck when instructed; report exact output on failure.',
         '',
-        '## Git boundary — do NOT run these commands:',
+        '## Verification',
+        '- Always verify your own work before reporting done.',
+        '- Run tests, lint, or typecheck when the instruction says to.',
+        '- If no verification was specified, still run relevant tests if they exist.',
+        '- Report exact output on failure.',
+        '',
+        '## Git boundary — do NOT run:',
         'git commit, git push, git reset, git checkout, git stash.',
-        'The CTO handles all git operations externally.',
+        'Git operations are handled externally.',
         '',
         '## Reporting',
-        '- End with a brief verification summary: what was done, what was verified.',
-        '- Report blockers immediately with specifics: file, line, error message.',
-        '- If a task is partially complete, state exactly what remains.',
+        '- End with: what was done, what was verified, what passed/failed.',
+        '- Report blockers immediately with specifics: file, line, error.',
+        '- If partially complete, state exactly what remains.',
     ].join('\n'),
     modePrefixes: {
         plan: [
-            '[PLAN MODE] You are in read-only planning mode. Do NOT create or edit any files.',
-            'Do NOT use ExitPlanMode or write plan artifacts to disk.',
+            '[PLAN MODE] Read-only. Do NOT create or edit any files.',
+            'Do NOT use ExitPlanMode or write artifacts to disk.',
             'Use read, grep, glob, and search tools only.',
             'Analyze the codebase and produce a detailed implementation plan:',
             'files to change, functions to modify, new files to create, test strategy,',
-            'and potential risks. End with a numbered step-by-step plan.',
-            'Return the entire plan inline in your response text.',
+            'and risks. End with a numbered step-by-step plan.',
+            'Return the entire plan inline in your response.',
         ].join(' '),
         free: '',
     },

package/dist/state/file-run-state-store.js

@@ -1,6 +1,6 @@
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
-import { isFileNotFoundError, writeJsonAtomically, } from '../util/fs-helpers.js';
+import { isFileNotFoundError, writeJsonAtomically } from '../util/fs-helpers.js';
 export class FileRunStateStore {
     baseDirectoryName;
     writeQueues = new Map();
@@ -70,9 +70,7 @@ export class FileRunStateStore {
     }
     async enqueueWrite(key, operation) {
         const previousOperation = this.writeQueues.get(key) ?? Promise.resolve();
-        const resultPromise = previousOperation
-            .catch(() => undefined)
-            .then(operation);
+        const resultPromise = previousOperation.catch(() => undefined).then(operation);
         const settledPromise = resultPromise.then(() => undefined, () => undefined);
         this.writeQueues.set(key, settledPromise);
         try {

package/dist/state/transcript-store.js

@@ -1,7 +1,7 @@
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
-import { appendTranscriptEvents, stripTrailingPartials, } from '../util/transcript-append.js';
-import { isFileNotFoundError, writeJsonAtomically, } from '../util/fs-helpers.js';
+import { appendTranscriptEvents, stripTrailingPartials } from '../util/transcript-append.js';
+import { isFileNotFoundError, writeJsonAtomically } from '../util/fs-helpers.js';
 export class TranscriptStore {
     baseDirectoryName;
     constructor(baseDirectoryName = '.claude-manager') {

package/dist/types/contracts.d.ts

@@ -13,7 +13,6 @@ export interface ManagerPromptRegistry {
         critical: string;
     };
 }
-export type ClaudeSettingSource = 'user' | 'project' | 'local';
 export type SessionMode = 'plan' | 'free';
 export interface ClaudeCommandMetadata {
     name: string;
@@ -22,34 +21,12 @@ export interface ClaudeCommandMetadata {
     source: 'sdk' | 'skill' | 'command';
     path?: string;
 }
-export interface ClaudeSkillMetadata {
-    name: string;
-    description: string;
-    path: string;
-    source: 'skill' | 'command';
-}
-export interface ClaudeHookMetadata {
-    name: string;
-    matcher?: string;
-    sourcePath: string;
-    commandCount: number;
-}
 export interface ClaudeAgentMetadata {
     name: string;
     description: string;
     model?: string;
     source: 'sdk' | 'filesystem';
 }
-export interface ClaudeMetadataSnapshot {
-    collectedAt: string;
-    cwd: string;
-    commands: ClaudeCommandMetadata[];
-    skills: ClaudeSkillMetadata[];
-    hooks: ClaudeHookMetadata[];
-    agents: ClaudeAgentMetadata[];
-    claudeMdPath?: string;
-    settingsPaths: string[];
-}
 export interface ClaudeSessionEvent {
     type: 'init' | 'assistant' | 'partial' | 'user' | 'tool_call' | 'tool_progress' | 'tool_summary' | 'status' | 'system' | 'result' | 'error';
     sessionId?: string;
@@ -75,7 +52,7 @@ export interface RunClaudeSessionInput {
     forkSession?: boolean;
     persistSession?: boolean;
     includePartialMessages?: boolean;
-    settingSources?: ClaudeSettingSource[];
+    settingSources?: Array<'user' | 'project' | 'local'>;
     maxTurns?: number;
     abortSignal?: AbortSignal;
 }

package/dist/util/fs-helpers.js

@@ -6,7 +6,5 @@ export async function writeJsonAtomically(filePath, data) {
     await fs.rename(tempPath, filePath);
 }
 export function isFileNotFoundError(error) {
-    return (error instanceof Error &&
-        'code' in error &&
-        error.code === 'ENOENT');
+    return (error instanceof Error && 'code' in error && error.code === 'ENOENT');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doingdev/opencode-claude-manager-plugin",
-  "version": "0.1.29",
+  "version": "0.1.31",
   "description": "OpenCode plugin that orchestrates Claude Code sessions.",
   "keywords": [
     "opencode",
@@ -31,7 +31,6 @@
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.2.81",
     "@opencode-ai/plugin": "^1.2.27",
-    "json5": "^2.2.3",
     "zod": "^4.1.8"
   },
   "devDependencies": {