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

package/dist/plugin/agent-hierarchy.js

@@ -1,17 +1,17 @@
 /**
  * Agent hierarchy configuration for the CTO + Engineer Wrapper architecture.
  *
- * CTO (cto)                      — pure orchestrator, spawns engineers, reviews diffs, commits
- * Engineer Plan (engineer_plan)   — manages a Claude Code session for read-only investigation
- * Engineer Build (engineer_build) — manages a Claude Code session for implementation
- * Claude Code session             — the underlying AI session (prompt only, no OpenCode agent)
+ * CTO (cto)                            — pure orchestrator, spawns engineers, reviews diffs, commits
+ * Engineer Explore (engineer_explore)   — manages a Claude Code session for read-only investigation
+ * Engineer Implement (engineer_implement) — manages a Claude Code session for implementation
+ * Claude Code session                   — the underlying AI session (prompt only, no OpenCode agent)
  */
 // ---------------------------------------------------------------------------
 // Agent names
 // ---------------------------------------------------------------------------
 export const AGENT_CTO = 'cto';
-export const AGENT_ENGINEER_PLAN = 'engineer_plan';
-export const AGENT_ENGINEER_BUILD = 'engineer_build';
+export const AGENT_ENGINEER_EXPLORE = 'engineer_explore';
+export const AGENT_ENGINEER_IMPLEMENT = 'engineer_implement';
 // ---------------------------------------------------------------------------
 // Tool IDs — grouped by domain
 // ---------------------------------------------------------------------------
@@ -25,12 +25,12 @@ const ENGINEER_SHARED_TOOL_IDS = [
 ];
 /** 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 = ['explore', ...ENGINEER_SHARED_TOOL_IDS];
-/** Tools for the engineer_build wrapper (build-mode send + shared) */
-const ENGINEER_BUILD_TOOL_IDS = ['implement', ...ENGINEER_SHARED_TOOL_IDS];
+/** Tools for the engineer_explore wrapper (explore-mode send + shared) */
+const ENGINEER_EXPLORE_TOOL_IDS = ['explore', ...ENGINEER_SHARED_TOOL_IDS];
+/** Tools for the engineer_implement wrapper (implement-mode send + shared) */
+const ENGINEER_IMPLEMENT_TOOL_IDS = ['implement', ...ENGINEER_SHARED_TOOL_IDS];
 /** Git tools — owned by CTO */
-const GIT_TOOL_IDS = ['git_diff', 'git_commit', 'git_reset'];
+const GIT_TOOL_IDS = ['git_diff', 'git_commit', 'git_reset', 'git_status', 'git_log'];
 /** Approval tools — owned by CTO */
 const APPROVAL_TOOL_IDS = ['approval_policy', 'approval_decisions', 'approval_update'];
 /** All restricted tool IDs (union of all domain groups) */
@@ -77,19 +77,19 @@ function buildCtoPermissions() {
         ...allowed,
         task: {
             '*': 'deny',
-            [AGENT_ENGINEER_PLAN]: 'allow',
-            [AGENT_ENGINEER_BUILD]: 'allow',
+            [AGENT_ENGINEER_EXPLORE]: 'allow',
+            [AGENT_ENGINEER_IMPLEMENT]: 'allow',
         },
     };
 }
-/** Engineer plan wrapper: read-only investigation + explore + shared session tools. */
-function buildEngineerPlanPermissions() {
+/** Engineer explore wrapper: read-only investigation + explore + shared session tools. */
+function buildEngineerExplorePermissions() {
     const denied = {};
     for (const toolId of ALL_RESTRICTED_TOOL_IDS) {
         denied[toolId] = 'deny';
     }
     const allowed = {};
-    for (const toolId of ENGINEER_PLAN_TOOL_IDS) {
+    for (const toolId of ENGINEER_EXPLORE_TOOL_IDS) {
         allowed[toolId] = 'allow';
     }
     return {
@@ -99,14 +99,14 @@ function buildEngineerPlanPermissions() {
         ...allowed,
     };
 }
-/** Engineer build wrapper: read-only investigation + implement + shared session tools. */
-function buildEngineerBuildPermissions() {
+/** Engineer implement wrapper: read-only investigation + implement + shared session tools. */
+function buildEngineerImplementPermissions() {
     const denied = {};
     for (const toolId of ALL_RESTRICTED_TOOL_IDS) {
         denied[toolId] = 'deny';
     }
     const allowed = {};
-    for (const toolId of ENGINEER_BUILD_TOOL_IDS) {
+    for (const toolId of ENGINEER_IMPLEMENT_TOOL_IDS) {
         allowed[toolId] = 'allow';
     }
     return {
@@ -128,22 +128,22 @@ export function buildCtoAgentConfig(prompts) {
         prompt: prompts.ctoSystemPrompt,
     };
 }
-export function buildEngineerPlanAgentConfig(prompts) {
+export function buildEngineerExploreAgentConfig(prompts) {
     return {
         description: 'Thin high-judgment wrapper that frames work quickly and dispatches to Claude Code in plan mode for read-only investigation.',
         mode: 'subagent',
         color: '#D97757',
-        permission: buildEngineerPlanPermissions(),
-        prompt: prompts.engineerPlanPrompt,
+        permission: buildEngineerExplorePermissions(),
+        prompt: prompts.engineerExplorePrompt,
     };
 }
-export function buildEngineerBuildAgentConfig(prompts) {
+export function buildEngineerImplementAgentConfig(prompts) {
     return {
         description: 'Thin high-judgment wrapper that frames work quickly and dispatches to Claude Code in free mode for implementation.',
         mode: 'subagent',
         color: '#D97757',
-        permission: buildEngineerBuildPermissions(),
-        prompt: prompts.engineerBuildPrompt,
+        permission: buildEngineerImplementPermissions(),
+        prompt: prompts.engineerImplementPrompt,
     };
 }
 // ---------------------------------------------------------------------------

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

@@ -1,16 +1,16 @@
 import { tool } from '@opencode-ai/plugin';
 import { composeWrapperPrompt, managerPromptRegistry } from '../prompts/registry.js';
 import { discoverProjectClaudeFiles } from '../util/project-context.js';
-import { AGENT_CTO, AGENT_ENGINEER_BUILD, AGENT_ENGINEER_PLAN, buildCtoAgentConfig, buildEngineerBuildAgentConfig, buildEngineerPlanAgentConfig, denyRestrictedToolsGlobally, } from './agent-hierarchy.js';
+import { AGENT_CTO, AGENT_ENGINEER_EXPLORE, AGENT_ENGINEER_IMPLEMENT, buildCtoAgentConfig, buildEngineerExploreAgentConfig, buildEngineerImplementAgentConfig, denyRestrictedToolsGlobally, } from './agent-hierarchy.js';
 import { getOrCreatePluginServices } from './service-factory.js';
 export const ClaudeManagerPlugin = async ({ worktree }) => {
     const services = getOrCreatePluginServices(worktree);
     async function executeDelegate(args, context) {
-        const cwd = args.cwd ?? context.worktree;
+        const wrapperServices = getOrCreatePluginServices(context.worktree);
         if (args.freshSession) {
-            await services.manager.clearSession(cwd);
+            await wrapperServices.manager.clearSession();
         }
-        const hasActiveSession = services.manager.getStatus().sessionId !== null;
+        const hasActiveSession = wrapperServices.manager.getStatus().sessionId !== null;
         const promptPreview = args.message.length > 100 ? args.message.slice(0, 100) + '...' : args.message;
         context.metadata({
             title: hasActiveSession
@@ -18,16 +18,17 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                 : '⚡ Claude Code: Initializing...',
             metadata: {
                 status: 'running',
-                sessionId: services.manager.getStatus().sessionId,
+                sessionId: wrapperServices.manager.getStatus().sessionId,
                 prompt: promptPreview,
             },
         });
         let turnsSoFar;
         let costSoFar;
-        const result = await services.manager.sendMessage(cwd, args.message, {
+        const result = await wrapperServices.manager.sendMessage(context.worktree, args.message, {
             model: args.model,
             effort: args.effort,
             mode: args.mode,
+            sessionSystemPrompt: args.sessionSystemPrompt,
             abortSignal: context.abort,
         }, (event) => {
             if (event.turns !== undefined) {
@@ -182,7 +183,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
         let toolOutputs = [];
         if (result.sessionId) {
             try {
-                toolOutputs = await services.liveTailer.getToolOutputPreview(result.sessionId, cwd, 3);
+                toolOutputs = await wrapperServices.liveTailer.getToolOutputPreview(result.sessionId, context.worktree, 3);
             }
             catch {
                 // Non-critical — the JSONL file may not exist yet.
@@ -210,12 +211,12 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
             const claudeFiles = await discoverProjectClaudeFiles(worktree);
             const derivedPrompts = {
                 ...managerPromptRegistry,
-                engineerPlanPrompt: composeWrapperPrompt(managerPromptRegistry.engineerPlanPrompt, claudeFiles),
-                engineerBuildPrompt: composeWrapperPrompt(managerPromptRegistry.engineerBuildPrompt, claudeFiles),
+                engineerExplorePrompt: composeWrapperPrompt(managerPromptRegistry.engineerExplorePrompt, claudeFiles),
+                engineerImplementPrompt: composeWrapperPrompt(managerPromptRegistry.engineerImplementPrompt, claudeFiles),
             };
             config.agent[AGENT_CTO] ??= buildCtoAgentConfig(managerPromptRegistry);
-            config.agent[AGENT_ENGINEER_PLAN] ??= buildEngineerPlanAgentConfig(derivedPrompts);
-            config.agent[AGENT_ENGINEER_BUILD] ??= buildEngineerBuildAgentConfig(derivedPrompts);
+            config.agent[AGENT_ENGINEER_EXPLORE] ??= buildEngineerExploreAgentConfig(derivedPrompts);
+            config.agent[AGENT_ENGINEER_IMPLEMENT] ??= buildEngineerImplementAgentConfig(derivedPrompts);
         },
         tool: {
             explore: tool({
@@ -225,14 +226,14 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                 args: {
                     message: tool.schema.string().min(1),
                     model: tool.schema
-                        .enum(['claude-opus-4-6', 'claude-sonnet-4-6', 'claude-sonnet-4-5'])
+                        .enum(['claude-opus-4-6', 'claude-sonnet-4-6'])
                         .optional(),
-                    effort: tool.schema.enum(['low', 'medium', 'high', 'max']).default('high'),
+                    effort: tool.schema.enum(['medium', 'high', 'max']).default('high'),
                     freshSession: tool.schema.boolean().default(false),
-                    cwd: tool.schema.string().optional(),
+                    sessionSystemPrompt: tool.schema.string().optional(),
                 },
                 async execute(args, context) {
-                    return executeDelegate({ ...args, mode: 'plan' }, context);
+                    return executeDelegate({ ...args, mode: 'plan', wrapperType: 'explore' }, context);
                 },
             }),
             implement: tool({
@@ -241,27 +242,27 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                 args: {
                     message: tool.schema.string().min(1),
                     model: tool.schema
-                        .enum(['claude-opus-4-6', 'claude-sonnet-4-6', 'claude-sonnet-4-5'])
+                        .enum(['claude-opus-4-6', 'claude-sonnet-4-6'])
                         .optional(),
-                    effort: tool.schema.enum(['low', 'medium', 'high', 'max']).default('high'),
+                    effort: tool.schema.enum(['medium', 'high', 'max']).default('high'),
                     freshSession: tool.schema.boolean().default(false),
-                    cwd: tool.schema.string().optional(),
+                    sessionSystemPrompt: tool.schema.string().optional(),
                 },
                 async execute(args, context) {
-                    return executeDelegate({ ...args, mode: 'free' }, context);
+                    return executeDelegate({ ...args, mode: 'free', wrapperType: 'implement' }, context);
                 },
             }),
             compact_context: tool({
                 description: 'Compress session history to reclaim context window space. ' +
                     'Preserves state while reducing token usage.',
                 args: {
-                    cwd: tool.schema.string().optional(),
+                    wrapperType: tool.schema.string().optional(),
                 },
                 async execute(args, context) {
-                    const cwd = args.cwd ?? context.worktree;
+                    const wrapperServices = getOrCreatePluginServices(context.worktree);
                     annotateToolRun(context, 'Compacting session', {});
-                    const result = await services.manager.compactSession(cwd);
-                    const snap = services.manager.getStatus();
+                    const result = await wrapperServices.manager.compactSession(context.worktree);
+                    const snap = wrapperServices.manager.getStatus();
                     const contextWarning = formatContextWarning(snap);
                     context.metadata({
                         title: contextWarning
@@ -283,13 +284,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);
                 },
             }),
@@ -297,7 +312,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', {
@@ -308,39 +322,61 @@ 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);
                 },
             }),
+            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(),
+                    wrapperType: tool.schema.string().optional(),
                     reason: tool.schema.string().optional(),
                 },
                 async execute(args, context) {
+                    const wrapperServices = getOrCreatePluginServices(context.worktree);
                     annotateToolRun(context, 'Clearing session', {
                         reason: args.reason,
                     });
-                    const clearedId = await services.manager.clearSession(args.cwd ?? context.worktree);
+                    const clearedId = await wrapperServices.manager.clearSession();
                     return JSON.stringify({ clearedSessionId: clearedId });
                 },
             }),
             session_health: tool({
                 description: 'Check session health metrics: context usage %, turn count, cost, and session ID.',
                 args: {
-                    cwd: tool.schema.string().optional(),
+                    wrapperType: tool.schema.string().optional(),
                 },
-                async execute(_args, context) {
+                async execute(args, context) {
+                    const wrapperServices = getOrCreatePluginServices(context.worktree);
                     annotateToolRun(context, 'Checking session status', {});
-                    const status = services.manager.getStatus();
+                    const status = wrapperServices.manager.getStatus();
                     return JSON.stringify({
                         ...status,
                         transcriptFile: status.sessionId
@@ -353,39 +389,40 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
             list_transcripts: tool({
                 description: 'List available session transcripts or inspect a specific transcript by ID.',
                 args: {
-                    cwd: tool.schema.string().optional(),
+                    wrapperType: tool.schema.string().optional(),
                     sessionId: tool.schema.string().optional(),
                 },
                 async execute(args, context) {
+                    const wrapperServices = getOrCreatePluginServices(context.worktree);
                     annotateToolRun(context, 'Inspecting Claude session history', {});
-                    const cwd = args.cwd ?? context.worktree;
                     if (args.sessionId) {
                         const [sdkTranscript, localEvents] = await Promise.all([
-                            services.sessions.getTranscript(args.sessionId, cwd),
-                            services.manager.getTranscriptEvents(cwd, args.sessionId),
+                            wrapperServices.sessions.getTranscript(args.sessionId, context.worktree),
+                            wrapperServices.manager.getTranscriptEvents(context.worktree, args.sessionId),
                         ]);
                         return JSON.stringify({
                             sdkTranscript,
                             localEvents: localEvents.length > 0 ? localEvents : undefined,
                         }, null, 2);
                     }
-                    const sessions = await services.sessions.listSessions(cwd);
+                    const sessions = await wrapperServices.sessions.listSessions(context.worktree);
                     return JSON.stringify(sessions, null, 2);
                 },
             }),
             list_history: tool({
                 description: 'List persistent run records from the manager or inspect a specific run.',
                 args: {
-                    cwd: tool.schema.string().optional(),
+                    wrapperType: tool.schema.string().optional(),
                     runId: tool.schema.string().optional(),
                 },
                 async execute(args, context) {
+                    const wrapperServices = getOrCreatePluginServices(context.worktree);
                     annotateToolRun(context, 'Reading manager run state', {});
                     if (args.runId) {
-                        const run = await services.manager.getRun(args.cwd ?? context.worktree, args.runId);
+                        const run = await wrapperServices.manager.getRun(context.worktree, args.runId);
                         return JSON.stringify(run, null, 2);
                     }
-                    const runs = await services.manager.listRuns(args.cwd ?? context.worktree);
+                    const runs = await wrapperServices.manager.listRuns(context.worktree);
                     return JSON.stringify(runs, null, 2);
                 },
             }),

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

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

package/dist/plugin/orchestrator.plugin.js

@@ -0,0 +1,116 @@
+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/plugin/service-factory.js

@@ -9,23 +9,19 @@ import { GitOperations } from '../manager/git-operations.js';
 import { SessionController } from '../manager/session-controller.js';
 import { PersistentManager } from '../manager/persistent-manager.js';
 import { managerPromptRegistry } from '../prompts/registry.js';
-const serviceCache = new Map();
 export function getOrCreatePluginServices(worktree) {
-    const cachedServices = serviceCache.get(worktree);
-    if (cachedServices) {
-        return cachedServices;
-    }
     const approvalManager = new ToolApprovalManager();
     const sdkAdapter = new ClaudeAgentSdkAdapter(undefined, approvalManager);
     const sessionService = new ClaudeSessionService(sdkAdapter);
     const contextTracker = new ContextTracker();
-    const sessionController = new SessionController(sdkAdapter, contextTracker, managerPromptRegistry.engineerSessionPrompt, managerPromptRegistry.modePrefixes);
+    const sessionController = new SessionController(sdkAdapter, contextTracker, undefined, // session prompt is now constructed dynamically by the wrapper
+    'default', worktree, managerPromptRegistry.modePrefixes);
     const gitOps = new GitOperations(worktree);
     const stateStore = new FileRunStateStore();
     const transcriptStore = new TranscriptStore();
     const manager = new PersistentManager(sessionController, gitOps, stateStore, contextTracker, transcriptStore);
     // Try to restore active session state (fire and forget)
-    manager.tryRestore(worktree).catch(() => { });
+    manager.tryRestore().catch(() => { });
     const liveTailer = new SessionLiveTailer();
     const services = {
         manager,
@@ -33,6 +29,5 @@ export function getOrCreatePluginServices(worktree) {
         approvalManager,
         liveTailer,
     };
-    serviceCache.set(worktree, services);
     return services;
 }