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

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

@@ -0,0 +1,563 @@
+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 { 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;
+        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: {
+                status: 'running',
+                sessionId: services.manager.getStatus().sessionId,
+                prompt: promptPreview,
+            },
+        });
+        let turnsSoFar;
+        let costSoFar;
+        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 usageSuffix = formatLiveUsage(turnsSoFar, costSoFar);
+            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}...${usageSuffix}`,
+                    metadata: {
+                        status: 'running',
+                        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...${usageSuffix}`,
+                    metadata: {
+                        status: 'running',
+                        sessionId: event.sessionId,
+                        type: event.type,
+                        thinking: thinkingPreview,
+                    },
+                });
+            }
+            else if (event.type === 'init') {
+                context.metadata({
+                    title: `⚡ Claude Code: Session started`,
+                    metadata: {
+                        status: 'running',
+                        sessionId: event.sessionId,
+                        prompt: promptPreview,
+                    },
+                });
+            }
+            else if (event.type === 'user') {
+                const preview = event.text.length > 200 ? event.text.slice(0, 200) + '...' : event.text;
+                const outputPreview = formatToolOutputPreview(event.text);
+                context.metadata({
+                    title: `⚡ Claude Code: ${outputPreview}${usageSuffix}`,
+                    metadata: {
+                        status: 'running',
+                        sessionId: event.sessionId,
+                        type: event.type,
+                        output: preview,
+                    },
+                });
+            }
+            else if (event.type === 'tool_progress') {
+                let toolName = 'tool';
+                let elapsed = 0;
+                let progressCurrent;
+                let progressTotal;
+                try {
+                    const parsed = JSON.parse(event.text);
+                    toolName = parsed.name ?? 'tool';
+                    elapsed = parsed.elapsed ?? 0;
+                    progressCurrent = parsed.current;
+                    progressTotal = parsed.total;
+                }
+                catch {
+                    // ignore
+                }
+                const progressInfo = progressCurrent !== undefined && progressTotal !== undefined
+                    ? ` [${progressCurrent}/${progressTotal}]`
+                    : '';
+                context.metadata({
+                    title: `⚡ Claude Code: ${toolName} running ${elapsed > 0 ? `(${elapsed.toFixed(0)}s)` : ''}${progressInfo}...${usageSuffix}`,
+                    metadata: {
+                        status: 'running',
+                        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${usageSuffix}`,
+                    metadata: {
+                        status: 'success',
+                        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...${usageSuffix}`,
+                    metadata: {
+                        status: 'running',
+                        sessionId: event.sessionId,
+                        type: event.type,
+                        delta,
+                    },
+                });
+            }
+            else if (event.type === 'error') {
+                context.metadata({
+                    title: `❌ Claude Code: Error`,
+                    metadata: {
+                        status: 'error',
+                        sessionId: event.sessionId,
+                        error: event.text.slice(0, 200),
+                    },
+                });
+                showToastIfAvailable(context, `Claude Code error: ${event.text.slice(0, 100)}`);
+            }
+        });
+        const costLabel = `$${(result.totalCostUsd ?? 0).toFixed(4)}`;
+        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: { status: 'warning', sessionId: result.sessionId, contextWarning },
+            });
+            showToastIfAvailable(context, `⚠️ Context usage at ${result.context.estimatedContextPercent}% — consider compacting`);
+        }
+        else {
+            context.metadata({
+                title: `✅ Claude Code: Complete (${turns} turns, ${costLabel})`,
+                metadata: { status: 'success', sessionId: result.sessionId },
+            });
+            showToastIfAvailable(context, `✅ Session complete (${turns} turns, ${costLabel})`);
+        }
+        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,
+            inputTokens: result.inputTokens,
+            outputTokens: result.outputTokens,
+            contextWindowSize: result.contextWindowSize,
+            context: result.context,
+            contextWarning,
+            toolOutputs: toolOutputs.length > 0 ? toolOutputs : undefined,
+        }, null, 2);
+    }
+    return {
+        config: async (config) => {
+            config.agent ??= {};
+            config.permission ??= {};
+            denyRestrictedToolsGlobally(config.permission);
+            // Discover project Claude files and build derived wrapper prompts.
+            const claudeFiles = await discoverProjectClaudeFiles(worktree);
+            const derivedPrompts = {
+                ...managerPromptRegistry,
+                engineerPlanPrompt: composeWrapperPrompt(managerPromptRegistry.engineerPlanPrompt, claudeFiles),
+                engineerBuildPrompt: composeWrapperPrompt(managerPromptRegistry.engineerBuildPrompt, claudeFiles),
+            };
+            config.agent[AGENT_CTO] ??= buildCtoAgentConfig(managerPromptRegistry);
+            config.agent[AGENT_ENGINEER_PLAN] ??= buildEngineerPlanAgentConfig(derivedPrompts);
+            config.agent[AGENT_ENGINEER_BUILD] ??= buildEngineerBuildAgentConfig(derivedPrompts);
+        },
+        tool: {
+            explore: tool({
+                description: 'Investigate and analyze code without making edits. ' +
+                    'Read-only exploration of the codebase. ' +
+                    'Preferred first step before implementation.',
+                args: {
+                    message: tool.schema.string().min(1),
+                    model: tool.schema
+                        .enum(['claude-opus-4-6', 'claude-sonnet-4-6', 'claude-sonnet-4-5'])
+                        .optional(),
+                    effort: tool.schema.enum(['low', 'medium', 'high', 'max']).default('high'),
+                    freshSession: tool.schema.boolean().default(false),
+                    cwd: tool.schema.string().optional(),
+                },
+                async execute(args, context) {
+                    return executeDelegate({ ...args, mode: 'plan' }, context);
+                },
+            }),
+            implement: tool({
+                description: 'Implement code changes - can read, edit, and create files. ' +
+                    'Use after exploration to make changes.',
+                args: {
+                    message: tool.schema.string().min(1),
+                    model: tool.schema
+                        .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 executeDelegate({ ...args, mode: 'free' }, 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(),
+                },
+                async execute(args, context) {
+                    const cwd = args.cwd ?? context.worktree;
+                    annotateToolRun(context, 'Compacting session', {});
+                    const result = await services.manager.compactSession(cwd);
+                    const snap = services.manager.getStatus();
+                    const contextWarning = formatContextWarning(snap);
+                    context.metadata({
+                        title: contextWarning
+                            ? `⚠️ Claude Code: Compacted — context at ${snap.estimatedContextPercent}%`
+                            : `✅ Claude Code: Compacted (${snap.totalTurns} turns, $${(snap.totalCostUsd ?? 0).toFixed(4)})`,
+                        metadata: {
+                            status: contextWarning ? 'warning' : 'success',
+                            sessionId: result.sessionId,
+                        },
+                    });
+                    return JSON.stringify({
+                        sessionId: result.sessionId,
+                        finalText: result.finalText,
+                        turns: result.turns,
+                        totalCostUsd: result.totalCostUsd,
+                        context: snap,
+                        contextWarning,
+                    }, null, 2);
+                },
+            }),
+            git_diff: tool({
+                description: 'Run git diff to see all current changes (staged + unstaged) relative to HEAD.',
+                args: {
+                    cwd: tool.schema.string().optional(),
+                },
+                async execute(_args, context) {
+                    annotateToolRun(context, 'Running git diff', {});
+                    const result = await services.manager.gitDiff();
+                    return JSON.stringify(result, null, 2);
+                },
+            }),
+            git_commit: tool({
+                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', {
+                        message: args.message,
+                    });
+                    const result = await services.manager.gitCommit(args.message);
+                    return JSON.stringify(result, null, 2);
+                },
+            }),
+            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(),
+                },
+                async execute(_args, context) {
+                    annotateToolRun(context, 'Resetting working directory', {});
+                    const result = await services.manager.gitReset();
+                    return JSON.stringify(result, null, 2);
+                },
+            }),
+            clear_session: tool({
+                description: 'Clear the active session to start fresh. ' +
+                    'Use when context is full or starting a new task.',
+                args: {
+                    cwd: tool.schema.string().optional(),
+                    reason: tool.schema.string().optional(),
+                },
+                async execute(args, context) {
+                    annotateToolRun(context, 'Clearing session', {
+                        reason: args.reason,
+                    });
+                    const clearedId = await services.manager.clearSession(args.cwd ?? context.worktree);
+                    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(),
+                },
+                async execute(_args, context) {
+                    annotateToolRun(context, 'Checking session status', {});
+                    const status = services.manager.getStatus();
+                    return JSON.stringify({
+                        ...status,
+                        transcriptFile: status.sessionId
+                            ? `.claude-manager/transcripts/${status.sessionId}.json`
+                            : null,
+                        contextWarning: formatContextWarning(status),
+                    }, null, 2);
+                },
+            }),
+            list_transcripts: tool({
+                description: 'List available session transcripts or inspect a specific transcript by ID.',
+                args: {
+                    cwd: tool.schema.string().optional(),
+                    sessionId: tool.schema.string().optional(),
+                },
+                async execute(args, context) {
+                    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),
+                        ]);
+                        return JSON.stringify({
+                            sdkTranscript,
+                            localEvents: localEvents.length > 0 ? localEvents : undefined,
+                        }, null, 2);
+                    }
+                    const sessions = await services.sessions.listSessions(cwd);
+                    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(),
+                    runId: tool.schema.string().optional(),
+                },
+                async execute(args, context) {
+                    annotateToolRun(context, 'Reading manager run state', {});
+                    if (args.runId) {
+                        const run = await services.manager.getRun(args.cwd ?? context.worktree, args.runId);
+                        return JSON.stringify(run, null, 2);
+                    }
+                    const runs = await services.manager.listRuns(args.cwd ?? context.worktree);
+                    return JSON.stringify(runs, null, 2);
+                },
+            }),
+            approval_policy: tool({
+                description: 'View the current tool approval policy: rules, default action, and enabled status.',
+                args: {},
+                async execute(_args, context) {
+                    annotateToolRun(context, 'Reading approval policy', {});
+                    return JSON.stringify(services.approvalManager.getPolicy(), null, 2);
+                },
+            }),
+            approval_decisions: tool({
+                description: 'View recent tool approval decisions. Shows what tools were allowed or denied. ' +
+                    'Use deniedOnly to see only denied calls.',
+                args: {
+                    limit: tool.schema.number().optional(),
+                    deniedOnly: tool.schema.boolean().optional(),
+                },
+                async execute(args, context) {
+                    annotateToolRun(context, 'Reading approval decisions', {});
+                    const decisions = args.deniedOnly
+                        ? services.approvalManager.getDeniedDecisions(args.limit)
+                        : services.approvalManager.getDecisions(args.limit);
+                    return JSON.stringify({ total: decisions.length, decisions }, null, 2);
+                },
+            }),
+            approval_update: tool({
+                description: 'Update the tool approval policy. Add/remove rules, change default action, or enable/disable. ' +
+                    'Rules are evaluated top-to-bottom; first match wins.',
+                args: {
+                    action: tool.schema.enum([
+                        'addRule',
+                        'removeRule',
+                        'setDefault',
+                        'setEnabled',
+                        'clearDecisions',
+                    ]),
+                    ruleId: tool.schema.string().optional(),
+                    toolPattern: tool.schema.string().optional(),
+                    inputPattern: tool.schema.string().optional(),
+                    ruleAction: tool.schema.enum(['allow', 'deny']).optional(),
+                    denyMessage: tool.schema.string().optional(),
+                    description: tool.schema.string().optional(),
+                    position: tool.schema.number().optional(),
+                    defaultAction: tool.schema.enum(['allow', 'deny']).optional(),
+                    enabled: tool.schema.boolean().optional(),
+                },
+                async execute(args, context) {
+                    annotateToolRun(context, `Updating approval: ${args.action}`, {});
+                    if (args.action === 'addRule') {
+                        if (!args.ruleId || !args.toolPattern || !args.ruleAction) {
+                            return JSON.stringify({
+                                error: 'addRule requires ruleId, toolPattern, and ruleAction',
+                            });
+                        }
+                        services.approvalManager.addRule({
+                            id: args.ruleId,
+                            toolPattern: args.toolPattern,
+                            inputPattern: args.inputPattern,
+                            action: args.ruleAction,
+                            denyMessage: args.denyMessage,
+                            description: args.description,
+                        }, args.position);
+                    }
+                    else if (args.action === 'removeRule') {
+                        if (!args.ruleId) {
+                            return JSON.stringify({ error: 'removeRule requires ruleId' });
+                        }
+                        const removed = services.approvalManager.removeRule(args.ruleId);
+                        return JSON.stringify({ removed });
+                    }
+                    else if (args.action === 'setDefault') {
+                        if (!args.defaultAction) {
+                            return JSON.stringify({
+                                error: 'setDefault requires defaultAction',
+                            });
+                        }
+                        services.approvalManager.setDefaultAction(args.defaultAction);
+                    }
+                    else if (args.action === 'setEnabled') {
+                        if (args.enabled === undefined) {
+                            return JSON.stringify({ error: 'setEnabled requires enabled' });
+                        }
+                        services.approvalManager.setEnabled(args.enabled);
+                    }
+                    else if (args.action === 'clearDecisions') {
+                        services.approvalManager.clearDecisions();
+                    }
+                    return JSON.stringify(services.approvalManager.getPolicy(), null, 2);
+                },
+            }),
+        },
+    };
+};
+function annotateToolRun(context, title, metadata, status) {
+    const emoji = status ? `${formatStatusEmoji(status)} ` : '';
+    context.metadata({
+        title: `${emoji}${title}`,
+        metadata: { ...metadata, ...(status ? { status } : {}) },
+    });
+}
+function formatLiveUsage(turns, cost) {
+    if (turns === undefined && cost === undefined) {
+        return '';
+    }
+    const parts = [];
+    if (turns !== undefined) {
+        parts.push(`🔄 ${turns} turns`);
+    }
+    if (cost !== undefined) {
+        parts.push(`💰 $${cost.toFixed(4)}`);
+    }
+    return ` (${parts.join(', ')})`;
+}
+function formatContextWarning(context) {
+    const { warningLevel, estimatedContextPercent, totalTurns, totalCostUsd } = context;
+    if (warningLevel === 'ok' || estimatedContextPercent === null) {
+        return null;
+    }
+    const templates = managerPromptRegistry.contextWarnings;
+    const template = warningLevel === 'critical'
+        ? templates.critical
+        : warningLevel === 'high'
+            ? templates.high
+            : templates.moderate;
+    return template
+        .replace('{percent}', String(estimatedContextPercent))
+        .replace('{turns}', String(totalTurns))
+        .replace('{cost}', totalCostUsd.toFixed(2));
+}
+function formatStatusEmoji(status) {
+    switch (status) {
+        case 'running':
+            return '⚡';
+        case 'success':
+            return '✅';
+        case 'error':
+            return '❌';
+        case 'warning':
+            return '⚠️';
+    }
+}
+function formatToolOutputPreview(text) {
+    const lower = text.toLowerCase();
+    let prefix;
+    if (lower.includes('"tool":"read"') ||
+        lower.includes('"name":"read"') ||
+        lower.includes('file contents')) {
+        prefix = '↳ Read: ';
+    }
+    else if (lower.includes('"tool":"grep"') ||
+        lower.includes('"name":"grep"') ||
+        lower.includes('matches found')) {
+        prefix = '↳ Found: ';
+    }
+    else if (lower.includes('"tool":"write"') ||
+        lower.includes('"name":"write"') ||
+        lower.includes('"tool":"edit"') ||
+        lower.includes('"name":"edit"') ||
+        lower.includes('file written') ||
+        lower.includes('file updated')) {
+        prefix = '↳ Wrote: ';
+    }
+    else {
+        prefix = '↳ Result: ';
+    }
+    const snippet = text.replace(/\s+/g, ' ').trim();
+    const truncated = snippet.length > 60 ? snippet.slice(0, 60) + '...' : snippet;
+    return `${prefix}${truncated}`;
+}
+function showToastIfAvailable(context, message) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const client = context.client;
+    client?.tui?.showToast?.(message);
+}

package/dist/src/plugin/service-factory.d.ts

@@ -0,0 +1,12 @@
+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 { PersistentManager } from '../manager/persistent-manager.js';
+interface ClaudeManagerPluginServices {
+    manager: PersistentManager;
+    sessions: ClaudeSessionService;
+    approvalManager: ToolApprovalManager;
+    liveTailer: SessionLiveTailer;
+}
+export declare function getOrCreatePluginServices(worktree: string): ClaudeManagerPluginServices;
+export {};

package/dist/src/plugin/service-factory.js

@@ -0,0 +1,38 @@
+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 { FileRunStateStore } from '../state/file-run-state-store.js';
+import { TranscriptStore } from '../state/transcript-store.js';
+import { ContextTracker } from '../manager/context-tracker.js';
+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 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(() => { });
+    const liveTailer = new SessionLiveTailer();
+    const services = {
+        manager,
+        sessions: sessionService,
+        approvalManager,
+        liveTailer,
+    };
+    serviceCache.set(worktree, services);
+    return services;
+}

package/dist/src/prompts/registry.d.ts

@@ -0,0 +1,11 @@
+import type { DiscoveredClaudeFile, ManagerPromptRegistry } from '../types/contracts.js';
+/**
+ * Compose a wrapper agent prompt from the base prompt plus discovered
+ * project Claude files. Returns the base prompt unchanged when no
+ * files are provided.
+ *
+ * Each file is rendered under a clear path-labeled section so the
+ * wrapper agent knows exactly where each instruction came from.
+ */
+export declare function composeWrapperPrompt(basePrompt: string, claudeFiles: DiscoveredClaudeFile[]): string;
+export declare const managerPromptRegistry: ManagerPromptRegistry;