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

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

@@ -21,6 +21,7 @@ export declare class PersistentManager {
         model?: string;
         effort?: 'low' | 'medium' | 'high' | 'max';
         mode?: 'plan' | 'free';
+        sessionSystemPrompt?: string;
         abortSignal?: AbortSignal;
     }, onEvent?: ClaudeSessionEventHandler): Promise<{
         sessionId: string | undefined;
@@ -66,7 +67,7 @@ export declare class PersistentManager {
     /**
      * Clear the active session. Next send creates a fresh one.
      */
-    clearSession(cwd: string): Promise<string | null>;
+    clearSession(): Promise<string | null>;
     /**
      * Compact the current session to free context.
      */
@@ -85,7 +86,7 @@ export declare class PersistentManager {
     /**
      * Try to restore session state from disk on startup.
      */
-    tryRestore(cwd: string): Promise<boolean>;
+    tryRestore(): Promise<boolean>;
     listRuns(cwd: string): Promise<PersistentRunRecord[]>;
     getRun(cwd: string, runId: string): Promise<PersistentRunRecord | null>;
 }

package/dist/manager/persistent-manager.js

@@ -17,7 +17,7 @@ export class PersistentManager {
      * Creates a new session if none exists.
      */
     async sendMessage(cwd, message, options, onEvent) {
-        const result = await this.sessionController.sendMessage(cwd, message, options, onEvent);
+        const result = await this.sessionController.sendMessage(message, options, onEvent);
         if (result.sessionId && result.events.length > 0) {
             await this.transcriptStore.appendEvents(cwd, result.sessionId, result.events);
         }
@@ -71,14 +71,14 @@ export class PersistentManager {
     /**
      * Clear the active session. Next send creates a fresh one.
      */
-    async clearSession(cwd) {
-        return this.sessionController.clearSession(cwd);
+    async clearSession() {
+        return this.sessionController.clearSession();
     }
     /**
      * Compact the current session to free context.
      */
     async compactSession(cwd, onEvent) {
-        const result = await this.sessionController.compactSession(cwd, onEvent);
+        const result = await this.sessionController.compactSession(onEvent);
         if (result.sessionId && result.events.length > 0) {
             await this.transcriptStore.appendEvents(cwd, result.sessionId, result.events);
         }
@@ -120,7 +120,7 @@ export class PersistentManager {
         await this.stateStore.saveRun(runRecord);
         await onProgress?.(runRecord);
         try {
-            const result = await this.sessionController.sendMessage(cwd, task, options, async (event) => {
+            const result = await this.sessionController.sendMessage(task, options, async (event) => {
                 // Update run record with progress events
                 const currentRun = await this.stateStore.getRun(cwd, runId);
                 if (currentRun) {
@@ -170,8 +170,8 @@ export class PersistentManager {
     /**
      * Try to restore session state from disk on startup.
      */
-    async tryRestore(cwd) {
-        return this.sessionController.tryRestore(cwd);
+    async tryRestore() {
+        return this.sessionController.tryRestore();
     }
     listRuns(cwd) {
         return this.stateStore.listRuns(cwd);

package/dist/manager/session-controller.d.ts

@@ -5,9 +5,11 @@ export declare class SessionController {
     private readonly sdkAdapter;
     private readonly contextTracker;
     private readonly sessionPrompt;
+    private readonly wrapperType;
+    private readonly worktree;
     private readonly modePrefixes;
     private activeSessionId;
-    constructor(sdkAdapter: ClaudeAgentSdkAdapter, contextTracker: ContextTracker, sessionPrompt: string, modePrefixes?: {
+    constructor(sdkAdapter: ClaudeAgentSdkAdapter, contextTracker: ContextTracker, sessionPrompt: string | undefined, wrapperType: string, worktree: string, modePrefixes?: {
         plan: string;
         free: string;
     });
@@ -17,20 +19,21 @@ export declare class SessionController {
      * Send a message to the persistent session. Creates one if none exists.
      * Returns the session result including usage data.
      */
-    sendMessage(cwd: string, message: string, options?: {
+    sendMessage(message: string, options?: {
         model?: string;
         effort?: 'low' | 'medium' | 'high' | 'max';
         mode?: SessionMode;
+        sessionSystemPrompt?: string;
         abortSignal?: AbortSignal;
     }, onEvent?: ClaudeSessionEventHandler): Promise<ClaudeSessionRunResult>;
     /**
      * Send /compact to the current session to compress context.
      */
-    compactSession(cwd: string, onEvent?: ClaudeSessionEventHandler): Promise<ClaudeSessionRunResult>;
+    compactSession(onEvent?: ClaudeSessionEventHandler): Promise<ClaudeSessionRunResult>;
     /**
      * Clear the current session. The next sendMessage will create a fresh one.
      */
-    clearSession(cwd: string): Promise<string | null>;
+    clearSession(): Promise<string | null>;
     /**
      * Get current context tracking snapshot.
      */
@@ -38,7 +41,7 @@ export declare class SessionController {
     /**
      * Try to restore active session from persisted state on startup.
      */
-    tryRestore(cwd: string): Promise<boolean>;
+    tryRestore(): Promise<boolean>;
     private persistActiveSession;
     private removeActiveSession;
 }

package/dist/manager/session-controller.js

@@ -1,19 +1,25 @@
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
-const ACTIVE_SESSION_FILE = '.claude-manager/active-session.json';
+import { dirname } from 'node:path';
+function activeSessionFile(_wrapperType) {
+    return `.claude-manager/active-session.json`;
+}
 export class SessionController {
     sdkAdapter;
     contextTracker;
     sessionPrompt;
+    wrapperType;
+    worktree;
     modePrefixes;
     activeSessionId = null;
-    constructor(sdkAdapter, contextTracker, sessionPrompt, modePrefixes = {
+    constructor(sdkAdapter, contextTracker, sessionPrompt, wrapperType, worktree, modePrefixes = {
         plan: '',
         free: '',
     }) {
         this.sdkAdapter = sdkAdapter;
         this.contextTracker = contextTracker;
         this.sessionPrompt = sessionPrompt;
+        this.wrapperType = wrapperType;
+        this.worktree = worktree;
         this.modePrefixes = modePrefixes;
     }
     get isActive() {
@@ -26,12 +32,12 @@ export class SessionController {
      * Send a message to the persistent session. Creates one if none exists.
      * Returns the session result including usage data.
      */
-    async sendMessage(cwd, message, options, onEvent) {
+    async sendMessage(message, options, onEvent) {
         const mode = options?.mode ?? 'free';
         const prefix = this.modePrefixes[mode];
         const prompt = prefix ? `${prefix}\n\n${message}` : message;
         const input = {
-            cwd,
+            cwd: this.worktree,
             prompt,
             persistSession: true,
             permissionMode: mode === 'plan' ? 'plan' : 'acceptEdits',
@@ -46,8 +52,8 @@ export class SessionController {
             input.resumeSessionId = this.activeSessionId;
         }
         else {
-            // New session — use the base session prompt (project context is in the wrapper)
-            input.systemPrompt = this.sessionPrompt;
+            // New session — prefer dynamically constructed prompt from wrapper, fall back to static default
+            input.systemPrompt = options?.sessionSystemPrompt ?? this.sessionPrompt;
             input.model ??= 'claude-opus-4-6';
             input.effort ??= 'high';
         }
@@ -66,28 +72,28 @@ export class SessionController {
             contextWindowSize: result.contextWindowSize,
         });
         // Persist active session state
-        await this.persistActiveSession(cwd);
+        await this.persistActiveSession();
         return result;
     }
     /**
      * Send /compact to the current session to compress context.
      */
-    async compactSession(cwd, onEvent) {
+    async compactSession(onEvent) {
         if (!this.activeSessionId) {
             throw new Error('No active session to compact');
         }
-        const result = await this.sendMessage(cwd, '/compact', undefined, onEvent);
+        const result = await this.sendMessage('/compact', undefined, onEvent);
         this.contextTracker.recordCompaction();
         return result;
     }
     /**
      * Clear the current session. The next sendMessage will create a fresh one.
      */
-    async clearSession(cwd) {
+    async clearSession() {
         const clearedId = this.activeSessionId;
         this.activeSessionId = null;
         this.contextTracker.reset();
-        await this.removeActiveSession(cwd);
+        await this.removeActiveSession();
         return clearedId;
     }
     /**
@@ -99,12 +105,12 @@ export class SessionController {
     /**
      * Try to restore active session from persisted state on startup.
      */
-    async tryRestore(cwd) {
-        const filePath = join(cwd, ACTIVE_SESSION_FILE);
+    async tryRestore() {
+        const filePath = activeSessionFile(this.wrapperType);
         try {
             const raw = await readFile(filePath, 'utf-8');
             const state = JSON.parse(raw);
-            if (state.sessionId && state.cwd === cwd) {
+            if (state.sessionId) {
                 this.activeSessionId = state.sessionId;
                 this.contextTracker.restore(state);
                 return true;
@@ -115,14 +121,13 @@ export class SessionController {
         }
         return false;
     }
-    async persistActiveSession(cwd) {
+    async persistActiveSession() {
         if (!this.activeSessionId) {
             return;
         }
         const snap = this.contextTracker.snapshot();
         const state = {
             sessionId: this.activeSessionId,
-            cwd,
             startedAt: new Date().toISOString(),
             totalTurns: snap.totalTurns,
             totalCostUsd: snap.totalCostUsd,
@@ -130,12 +135,12 @@ export class SessionController {
             contextWindowSize: snap.contextWindowSize,
             latestInputTokens: snap.latestInputTokens,
         };
-        const filePath = join(cwd, ACTIVE_SESSION_FILE);
+        const filePath = activeSessionFile(this.wrapperType);
         await mkdir(dirname(filePath), { recursive: true });
         await writeFile(filePath, JSON.stringify(state, null, 2));
     }
-    async removeActiveSession(cwd) {
-        const filePath = join(cwd, ACTIVE_SESSION_FILE);
+    async removeActiveSession() {
+        const filePath = activeSessionFile(this.wrapperType);
         try {
             const { unlink } = await import('node:fs/promises');
             await unlink(filePath);

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

@@ -1,15 +1,15 @@
 /**
  * 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)
  */
 import type { ManagerPromptRegistry } from '../types/contracts.js';
 export declare const AGENT_CTO = "cto";
-export declare const AGENT_ENGINEER_PLAN = "engineer_plan";
-export declare const AGENT_ENGINEER_BUILD = "engineer_build";
+export declare const AGENT_ENGINEER_EXPLORE = "engineer_explore";
+export declare const AGENT_ENGINEER_IMPLEMENT = "engineer_implement";
 /** All restricted tool IDs (union of all domain groups) */
 export declare const ALL_RESTRICTED_TOOL_IDS: readonly ["explore", "implement", "compact_context", "clear_session", "session_health", "list_transcripts", "list_history", "git_diff", "git_commit", "git_reset", "git_status", "git_log", "approval_policy", "approval_decisions", "approval_update"];
 type ToolPermission = 'allow' | 'ask' | 'deny';
@@ -41,14 +41,14 @@ export declare function buildCtoAgentConfig(prompts: ManagerPromptRegistry): {
     permission: AgentPermission;
     prompt: string;
 };
-export declare function buildEngineerPlanAgentConfig(prompts: ManagerPromptRegistry): {
+export declare function buildEngineerExploreAgentConfig(prompts: ManagerPromptRegistry): {
     description: string;
     mode: "subagent";
     color: string;
     permission: AgentPermission;
     prompt: string;
 };
-export declare function buildEngineerBuildAgentConfig(prompts: ManagerPromptRegistry): {
+export declare function buildEngineerImplementAgentConfig(prompts: ManagerPromptRegistry): {
     description: string;
     mode: "subagent";
     color: string;

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,10 +25,10 @@ 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', 'git_status', 'git_log'];
 /** Approval tools — owned by CTO */
@@ -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
@@ -355,25 +356,27 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                 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
@@ -386,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/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;
 }

package/dist/prompts/registry.js

@@ -13,6 +13,66 @@ export function composeWrapperPrompt(basePrompt, claudeFiles) {
     const sections = claudeFiles.map((f) => `### ${f.relativePath}\n${f.content}`).join('\n\n');
     return `${basePrompt}\n\n## Project Claude Files\nThe following project-level instructions were discovered from the repository.\n\n${sections}`;
 }
+/**
+ * Build an engineer wrapper prompt from shared sections plus mode-specific overrides.
+ */
+function buildEngineerWrapperPrompt(opts) {
+    return [
+        `You are a staff engineer managing a Claude Code session for ${opts.purpose}.`,
+        'You are not a forwarding layer — interpret the task in repo context before delegating.',
+        '',
+        '## Staff-level framing',
+        '- Identify the real problem, not just the stated request.',
+        '- Look for missing architecture, ownership, or precedence issues before delegating.',
+        '- Rewrite weak or underspecified requests into precise prompts for the engineer.',
+        '- For medium+ tasks, determine: the actual problem, the cleanest architecture,',
+        '  and what needs clarification before work begins.',
+        '- Ask ONE clarification first if it materially improves architecture.',
+        '',
+        '## Repo-context investigation',
+        '- Use read/grep/glob sparingly — only for spot-checks to sharpen a delegation.',
+        '- Do NOT implement changes yourself — investigation only.',
+        '',
+        '## Behavior',
+        `- Send the objective to the engineer using ${opts.toolName}.`,
+        "- Return the engineer's response verbatim. Do not summarize.",
+        `- Use freshSession:true on ${opts.toolName} when the task is unrelated to prior work.`,
+        '',
+        '## Constructing the engineer session prompt',
+        `When you call \`${opts.toolName}\`, you MUST include a \`sessionSystemPrompt\` argument.`,
+        'This becomes the system prompt for the underlying Claude Code session.',
+        'Build it as a self-contained description that equips the engineer to execute precisely.',
+        '',
+        'Structure it as:',
+        `1. **Role**: "${opts.roleDescription}"`,
+        '2. **Project rules**: Extract only the rules from the Project Claude Files below that',
+        '   are relevant to this specific task. Synthesize — do not dump everything.',
+        '   Cite file paths when the source matters (e.g. "per packages/core/CLAUDE.md").',
+        '3. **Verification**: How to verify the work (tests, lint, typecheck, expected behavior).',
+        '',
+        'Keep it concise: 3-6 sentences for role + relevant rules + verification.',
+        'The task itself goes in `message`, not in `sessionSystemPrompt`.',
+        '',
+        '## Context management',
+        '- Check session_health before sending.',
+        '- Under 50%: proceed. Over 70%: compact_context. Over 85%: clear_session.',
+        '',
+        '## Model selection',
+        ...opts.modelDefaults,
+        '',
+        '## Using appended Project Claude Files',
+        '- Treat appended Project Claude Files as project guidance for the engineer.',
+        '- Extract only the rules relevant to the current task when constructing sessionSystemPrompt.',
+        '- Prefer guidance from more specific/nested paths over root-level guidance on conflict.',
+        '- Direct user instructions override Claude-file guidance.',
+        '- Keep delegated instructions tight; do not dump the full file corpus unless needed.',
+        '- Cite file paths (e.g. "per packages/core/CLAUDE.md") when the source matters.',
+        '',
+        '## What you must NOT do',
+        '- Do NOT call git_*, approval_*, or any non-engineer tools.',
+        '- Do NOT add commentary to the engineer response.',
+    ].join('\n');
+}
 export const managerPromptRegistry = {
     ctoSystemPrompt: [
         'You are a staff+ technical owner who uses Claude Code better than anyone.',
@@ -25,7 +85,7 @@ export const managerPromptRegistry = {
         '- Verifying a result after an engineer returns.',
         '- Resolving one high-leverage ambiguity before dispatching.',
         'If you need more than 2 direct read/grep/glob lookups, stop and delegate',
-        'the investigation to `engineer_plan` instead.',
+        'the investigation to `engineer_explore` instead.',
         '',
         '## Core principle: technical ownership',
         'You are not a ticket-taker. Before acting, look for:',
@@ -51,12 +111,12 @@ export const managerPromptRegistry = {
         '  2. What is underspecified or conflicting.',
         '  3. What the cleanest architecture is.',
         '  4. What should be clarified before proceeding.',
-        '  Prefer spawning `engineer_plan` for repo exploration rather than reading',
+        '  Prefer spawning `engineer_explore` for repo exploration rather than reading',
         '  code yourself. Use at most 1-2 spot-check reads to sharpen the delegation.',
         '  Then delegate with file paths, line numbers, patterns, and verification.',
         '',
         '**Complex tasks** (multi-file feature, large refactor):',
-        '  1. Spawn `engineer_plan` to explore the repo, map dependencies, and analyze impact.',
+        '  1. Spawn `engineer_explore` to explore the repo, map dependencies, and analyze impact.',
         '  2. If requirements are unclear, ask the user ONE high-leverage question —',
         '     only when it materially changes architecture, ownership, or destructive behavior.',
         '     Prefer the question tool when discrete options exist.',
@@ -92,20 +152,20 @@ export const managerPromptRegistry = {
         '   style violations.',
         '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.',
+        '4. If correct: spawn `engineer_implement` to run tests/lint/typecheck.',
         '5. If tests pass: git_commit to checkpoint.',
-        '6. If wrong: spawn `engineer_build` with a specific correction.',
+        '6. If wrong: spawn `engineer_implement` with a specific correction.',
         '   On second failure: git_reset and rewrite the prompt from scratch.',
         '   Never send three corrections for the same problem.',
         '',
         '## Engineers (via the Task tool)',
-        '- `engineer_plan` — read-only investigation. Use for: exploring unfamiliar code,',
+        '- `engineer_explore` — 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.',
+        '- `engineer_implement` — implementation. Use for: all code changes, test runs, fixes.',
         '- If steps are independent, spawn multiple engineers in parallel.',
         '',
         '## Context efficiency',
-        '- Use `engineer_plan` for broad exploration so your own context stays clean.',
+        '- Use `engineer_explore` 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.',
         '',
@@ -134,106 +194,40 @@ export const managerPromptRegistry = {
         '- Destructive actions on shared state (deploy, publish, force-push).',
         'State the blocker, what you need, and a concrete suggestion to unblock.',
     ].join('\n'),
-    engineerPlanPrompt: [
-        'You are a staff engineer managing a Claude Code session for read-only investigation.',
-        'You are not a forwarding layer — interpret the task in repo context before delegating.',
-        '',
-        '## Staff-level framing',
-        '- Identify the real problem, not just the stated request.',
-        '- Look for missing architecture, ownership, or precedence issues before delegating.',
-        '- Rewrite weak or underspecified requests into precise prompts for the engineer.',
-        '- For medium+ tasks, determine: the actual problem, the cleanest architecture,',
-        '  and what needs clarification before work begins.',
-        '- Ask ONE clarification first if it materially improves architecture.',
-        '',
-        '## Repo-context investigation',
-        '- Use read/grep/glob sparingly — only for spot-checks to sharpen a delegation.',
-        '- If more than 2 lookups are needed, send the investigation to the engineer.',
-        '- Do NOT implement changes yourself — investigation only.',
-        '',
-        '## Behavior',
-        '- Send the objective to the engineer using explore.',
-        "- Return the engineer's response verbatim. Do not summarize.",
-        '- Use freshSession:true on explore when the task is unrelated to prior work.',
-        '',
-        '## Context management',
-        '- 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).',
-        '- claude-sonnet-4-6: lighter analysis.',
-        '- effort "medium": simple lookups.',
-        '',
-        '## Using appended Project Claude Files',
-        '- Treat appended Project Claude Files as project guidance for the engineer.',
-        '- Extract only the rules relevant to the current task when delegating.',
-        '- Prefer guidance from more specific/nested paths over root-level guidance on conflict.',
-        '- Direct user instructions override Claude-file guidance.',
-        '- Keep delegated instructions tight; do not dump the full file corpus unless needed.',
-        '- Cite file paths (e.g. "per packages/core/CLAUDE.md") when the source matters.',
-        '',
-        '## What you must NOT do',
-        '- Do NOT call git_*, approval_*, or any non-engineer tools.',
-        '- Do NOT add commentary to the engineer response.',
-    ].join('\n'),
-    engineerBuildPrompt: [
-        'You are a staff engineer managing a Claude Code session for implementation.',
-        'You are not a forwarding layer — interpret the task in repo context before delegating.',
-        '',
-        '## Staff-level framing',
-        '- Identify the real problem, not just the stated request.',
-        '- Look for missing architecture, ownership, or precedence issues before delegating.',
-        '- Rewrite weak or underspecified requests into precise prompts for the engineer.',
-        '- For medium+ tasks, determine: the actual problem, the cleanest architecture,',
-        '  and what needs clarification before work begins.',
-        '- Ask ONE clarification first if it materially improves architecture.',
-        '',
-        '## Repo-context investigation',
-        '- Use read/grep/glob sparingly — only for spot-checks to sharpen a delegation.',
-        '- If more than 2 lookups are needed, send the investigation to the engineer.',
-        '- Do NOT implement changes yourself — investigation only.',
-        '',
-        '## Behavior',
-        '- Send the objective to the engineer using implement.',
-        "- Return the engineer's response verbatim. Do not summarize.",
-        '- Use freshSession:true on implement when the task is unrelated to prior work.',
-        '',
-        '## Context management',
-        '- 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).',
-        '- claude-sonnet-4-6: simple renames, formatting, scaffolding.',
-        '- effort "max": complex refactors, subtle bugs, cross-cutting changes.',
-        '',
-        '## Using appended Project Claude Files',
-        '- Treat appended Project Claude Files as project guidance for the engineer.',
-        '- Extract only the rules relevant to the current task when delegating.',
-        '- Prefer guidance from more specific/nested paths over root-level guidance on conflict.',
-        '- Direct user instructions override Claude-file guidance.',
-        '- Keep delegated instructions tight; do not dump the full file corpus unless needed.',
-        '- Cite file paths (e.g. "per packages/core/CLAUDE.md") when the source matters.',
-        '',
-        '## What you must NOT do',
-        '- Do NOT call git_*, approval_*, or any non-engineer tools.',
-        '- Do NOT add commentary to the engineer response.',
-    ].join('\n'),
+    engineerExplorePrompt: buildEngineerWrapperPrompt({
+        purpose: 'read-only investigation',
+        toolName: 'explore',
+        roleDescription: 'You are an expert engineer performing read-only investigation. ' +
+            'Execute directly. No preamble. Follow existing repo conventions.',
+        modelDefaults: [
+            '- claude-opus-4-6 + high: complex analysis (default).',
+            '- claude-sonnet-4-6: lighter analysis.',
+            '- effort "medium": simple lookups.',
+        ],
+    }),
+    engineerImplementPrompt: buildEngineerWrapperPrompt({
+        purpose: 'implementation',
+        toolName: 'implement',
+        roleDescription: 'You are an expert engineer implementing changes. ' +
+            'Execute directly. No preamble. Follow existing repo conventions. ' +
+            'Do not run git commit, git push, git reset, git checkout, or git stash — git operations are handled externally.',
+        modelDefaults: [
+            '- 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.',
+        ],
+    }),
     engineerSessionPrompt: [
         'You are an expert engineer. Execute instructions precisely.',
         '',
         '## Rules',
         '- Execute directly. No preamble, no restating the task.',
-        '- Prefer targeted file reads over reading entire files.',
-        '- Use subagents for independent parallel work.',
-        '- Follow existing repo conventions (naming, style, patterns).',
+        '- Follow existing repo conventions.',
+        '- Report exact output on failure.',
         '',
         '## 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.',
@@ -241,8 +235,7 @@ export const managerPromptRegistry = {
         '',
         '## Reporting',
         '- 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.',
+        '- Report blockers immediately with specifics.',
     ].join('\n'),
     modePrefixes: {
         plan: [

package/dist/types/contracts.d.ts

@@ -1,7 +1,7 @@
 export interface ManagerPromptRegistry {
     ctoSystemPrompt: string;
-    engineerPlanPrompt: string;
-    engineerBuildPrompt: string;
+    engineerExplorePrompt: string;
+    engineerImplementPrompt: string;
     engineerSessionPrompt: string;
     modePrefixes: {
         plan: string;
@@ -113,7 +113,6 @@ export interface GitOperationResult {
 }
 export interface ActiveSessionState {
     sessionId: string;
-    cwd: string;
     startedAt: string;
     totalTurns: number;
     totalCostUsd: number;

package/package.json

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