@doingdev/opencode-claude-manager-plugin 0.1.0

package/README.md

@@ -0,0 +1,119 @@
+# OpenCode Claude Manager Plugin
+
+This package provides an OpenCode plugin that lets an OpenCode-side manager agent orchestrate Claude Code sessions through a stable local bridge.
+
+## Overview
+
+Use this when you want OpenCode to act as a manager over Claude Code instead of talking to Claude directly. The plugin gives OpenCode a stable tool surface for discovering Claude metadata, delegating work to Claude sessions, splitting tasks into subagents, and coordinating optional git worktrees.
+
+## Features
+
+- Runs Claude Code tasks from OpenCode through `@anthropic-ai/claude-agent-sdk`.
+- Discovers repo-local Claude metadata from `.claude/skills`, `.claude/commands`, `CLAUDE.md`, and settings hooks.
+- Splits multi-step tasks into subagents, optionally assigning dedicated git worktrees.
+- Persists manager runs under `.claude-manager/runs` so sessions can be inspected later.
+- Exposes manager-facing tools instead of relying on undocumented plugin-defined slash commands.
+
+## Requirements
+
+- Node `22+`
+- OpenCode with plugin loading enabled
+- Access to Claude Code / Claude Agent SDK on the machine where OpenCode is running
+- A git repository if you want automatic worktree allocation
+
+## Installation
+
+Install from npm:
+
+```bash
+npm install @doingdev/opencode-claude-manager-plugin
+```
+
+Or for local development in this repo:
+
+```bash
+npm install
+npm run build
+```
+
+## OpenCode Config
+
+Add the plugin to your OpenCode config:
+
+```json
+{
+  "plugin": ["@doingdev/opencode-claude-manager-plugin"]
+}
+```
+
+If you are testing locally, point OpenCode at the local package or plugin file using your normal local plugin workflow.
+
+## OpenCode tools
+
+- `claude_manager_run` - run a task through Claude with optional splitting and worktrees
+- `claude_manager_metadata` - inspect available Claude commands, skills, hooks, and settings
+- `claude_manager_sessions` - list Claude sessions or inspect a saved transcript
+- `claude_manager_runs` - inspect persisted manager run records
+- `claude_manager_cleanup_run` - explicitly remove worktrees created for a prior manager run
+
+## Quick Start
+
+Typical flow inside OpenCode:
+
+1. Inspect Claude capabilities with `claude_manager_metadata`.
+2. Delegate work with `claude_manager_run`.
+3. Inspect saved Claude history with `claude_manager_sessions` or prior orchestration records with `claude_manager_runs`.
+
+Example task:
+
+```text
+Use claude_manager_run to split this implementation into subagents, use worktrees, and summarize the final result.
+```
+
+## Local Development
+
+Clone the repo and run:
+
+```bash
+npm install
+npm run lint
+npm run typecheck
+npm run test
+npm run build
+```
+
+The compiled plugin output is written to `dist/`.
+
+## Publishing
+
+This package is configured for the npm scope `@doingdev`.
+
+Release flow:
+
+```bash
+npm login
+npm whoami
+npm version patch
+npm run lint
+npm run typecheck
+npm run test
+npm run build
+npm publish --access public
+```
+
+You can also publish through the GitHub Actions workflow after creating a GitHub release and configuring the `NPM_TOKEN` secret.
+
+## Limitations
+
+- Claude slash commands and skills come primarily from filesystem discovery; SDK probing is available but optional.
+- Worktree creation only activates when the current directory is a git repo and multiple subtasks are planned.
+- Worktrees are preserved by default so you can inspect changes; clean them up explicitly with `claude_manager_cleanup_run`.
+- Run state is local to the repo under `.claude-manager/` and is ignored by git.
+
+## Scripts
+
+- `npm run build`
+- `npm run typecheck`
+- `npm run lint`
+- `npm run format`
+- `npm run test`

package/dist/claude/claude-agent-sdk-adapter.d.ts

@@ -0,0 +1,24 @@
+import { type Options, type Query, type SDKSessionInfo, type SessionMessage, type SettingSource } from '@anthropic-ai/claude-agent-sdk';
+import type { ClaudeCapabilitySnapshot, ClaudeSessionEvent, ClaudeSessionRunResult, ClaudeSessionSummary, ClaudeSessionTranscriptMessage, RunClaudeSessionInput } from '../types/contracts.js';
+export type ClaudeSessionEventHandler = (event: ClaudeSessionEvent) => void | Promise<void>;
+export interface ClaudeAgentSdkFacade {
+    query(params: {
+        prompt: string;
+        options?: Options;
+    }): Query;
+    listSessions(options?: {
+        dir?: string;
+    }): Promise<SDKSessionInfo[]>;
+    getSessionMessages(sessionId: string, options?: {
+        dir?: string;
+    }): Promise<SessionMessage[]>;
+}
+export declare class ClaudeAgentSdkAdapter {
+    private readonly sdkFacade;
+    constructor(sdkFacade?: ClaudeAgentSdkFacade);
+    runSession(input: RunClaudeSessionInput, onEvent?: ClaudeSessionEventHandler): Promise<ClaudeSessionRunResult>;
+    listSavedSessions(cwd?: string): Promise<ClaudeSessionSummary[]>;
+    getTranscript(sessionId: string, cwd?: string): Promise<ClaudeSessionTranscriptMessage[]>;
+    probeCapabilities(cwd: string, settingSources?: SettingSource[]): Promise<ClaudeCapabilitySnapshot>;
+    private buildOptions;
+}

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

@@ -0,0 +1,256 @@
+import { getSessionMessages, listSessions, query, } from '@anthropic-ai/claude-agent-sdk';
+const defaultFacade = {
+    query,
+    listSessions,
+    getSessionMessages,
+};
+export class ClaudeAgentSdkAdapter {
+    sdkFacade;
+    constructor(sdkFacade = defaultFacade) {
+        this.sdkFacade = sdkFacade;
+    }
+    async runSession(input, onEvent) {
+        const sessionQuery = this.sdkFacade.query({
+            prompt: input.prompt,
+            options: this.buildOptions(input),
+        });
+        const events = [];
+        let finalText = '';
+        let sessionId;
+        let turns;
+        let totalCostUsd;
+        try {
+            for await (const message of sessionQuery) {
+                const event = normalizeSdkMessage(message);
+                if (!event) {
+                    continue;
+                }
+                sessionId ??= event.sessionId;
+                if (event.type === 'result') {
+                    finalText = event.text;
+                    turns = event.turns;
+                    totalCostUsd = event.totalCostUsd;
+                }
+                events.push(event);
+                if (onEvent) {
+                    await onEvent(event);
+                }
+            }
+        }
+        finally {
+            sessionQuery.close();
+        }
+        return {
+            sessionId,
+            events,
+            finalText,
+            turns,
+            totalCostUsd,
+        };
+    }
+    async listSavedSessions(cwd) {
+        const sessions = await this.sdkFacade.listSessions(cwd ? { dir: cwd } : undefined);
+        return sessions.map((session) => ({
+            sessionId: session.sessionId,
+            summary: session.summary,
+            cwd: session.cwd,
+            gitBranch: session.gitBranch,
+            createdAt: session.createdAt,
+            lastModified: session.lastModified,
+        }));
+    }
+    async getTranscript(sessionId, cwd) {
+        const messages = await this.sdkFacade.getSessionMessages(sessionId, cwd ? { dir: cwd } : undefined);
+        return messages.map((message) => ({
+            role: message.type,
+            sessionId: message.session_id,
+            messageId: message.uuid,
+            text: extractText(message.message),
+        }));
+    }
+    async probeCapabilities(cwd, settingSources = ['project']) {
+        const sessionQuery = this.sdkFacade.query({
+            prompt: 'Reply with OK.',
+            options: {
+                cwd,
+                maxTurns: 1,
+                permissionMode: 'plan',
+                persistSession: false,
+                tools: [],
+                settingSources,
+            },
+        });
+        try {
+            const [commands, agents, models] = await Promise.all([
+                sessionQuery.supportedCommands(),
+                sessionQuery.supportedAgents(),
+                sessionQuery.supportedModels(),
+            ]);
+            return {
+                commands: commands.map(mapSlashCommand),
+                agents: agents.map(mapAgent),
+                models: models.map((model) => model.value),
+            };
+        }
+        finally {
+            sessionQuery.close();
+        }
+    }
+    buildOptions(input) {
+        const options = {
+            cwd: input.cwd,
+            tools: { type: 'preset', preset: 'claude_code' },
+            allowedTools: input.allowedTools,
+            disallowedTools: input.disallowedTools,
+            continue: input.continueSession,
+            resume: input.resumeSessionId,
+            forkSession: input.forkSession,
+            persistSession: input.persistSession,
+            includePartialMessages: input.includePartialMessages,
+            settingSources: input.settingSources,
+            maxTurns: input.maxTurns,
+            model: input.model,
+            permissionMode: input.permissionMode,
+            systemPrompt: input.systemPrompt
+                ? { type: 'preset', preset: 'claude_code', append: input.systemPrompt }
+                : { type: 'preset', preset: 'claude_code' },
+            env: {
+                ...process.env,
+                CLAUDE_AGENT_SDK_CLIENT_APP: 'opencode-claude-manager-plugin/0.1.0',
+            },
+        };
+        if (!input.resumeSessionId) {
+            delete options.resume;
+        }
+        return options;
+    }
+}
+function normalizeSdkMessage(message) {
+    const sessionId = 'session_id' in message ? message.session_id : undefined;
+    if (message.type === 'assistant') {
+        return {
+            type: 'assistant',
+            sessionId,
+            text: extractText(message.message),
+            rawType: message.type,
+        };
+    }
+    if (message.type === 'stream_event') {
+        return {
+            type: 'partial',
+            sessionId,
+            text: extractPartialEventText(message.event),
+            rawType: message.type,
+        };
+    }
+    if (message.type === 'result') {
+        return {
+            type: message.is_error ? 'error' : 'result',
+            sessionId,
+            text: message.subtype === 'success'
+                ? message.result
+                : message.errors.join('\n') || message.subtype,
+            turns: message.num_turns,
+            totalCostUsd: message.total_cost_usd,
+            rawType: `${message.type}:${message.subtype}`,
+        };
+    }
+    if (message.type === 'system') {
+        return {
+            type: message.subtype === 'init' ? 'init' : 'system',
+            sessionId,
+            text: message.subtype,
+            rawType: `${message.type}:${message.subtype}`,
+        };
+    }
+    if (message.type === 'auth_status') {
+        return {
+            type: 'system',
+            sessionId,
+            text: message.output.join('\n') || 'auth_status',
+            rawType: message.type,
+        };
+    }
+    if (message.type === 'prompt_suggestion') {
+        return {
+            type: 'system',
+            sessionId,
+            text: message.suggestion,
+            rawType: message.type,
+        };
+    }
+    if (message.type === 'user') {
+        return null;
+    }
+    return {
+        type: 'system',
+        sessionId,
+        text: message.type,
+        rawType: message.type,
+    };
+}
+function extractPartialEventText(event) {
+    if (!event || typeof event !== 'object') {
+        return 'stream_event';
+    }
+    const eventRecord = event;
+    const eventType = typeof eventRecord.type === 'string' ? eventRecord.type : 'stream_event';
+    const delta = eventRecord.delta;
+    if (delta && typeof delta === 'object') {
+        const deltaRecord = delta;
+        if (typeof deltaRecord.text === 'string') {
+            return deltaRecord.text;
+        }
+        if (typeof deltaRecord.partial_json === 'string') {
+            return deltaRecord.partial_json;
+        }
+    }
+    return eventType;
+}
+function extractText(payload) {
+    if (typeof payload === 'string') {
+        return payload;
+    }
+    if (!payload || typeof payload !== 'object') {
+        return '';
+    }
+    const payloadRecord = payload;
+    if (Array.isArray(payloadRecord.content)) {
+        const parts = payloadRecord.content
+            .map((contentPart) => {
+            if (!contentPart || typeof contentPart !== 'object') {
+                return '';
+            }
+            const partRecord = contentPart;
+            if (typeof partRecord.text === 'string') {
+                return partRecord.text;
+            }
+            if (partRecord.type === 'tool_use' &&
+                typeof partRecord.name === 'string') {
+                return `[tool:${partRecord.name}]`;
+            }
+            return '';
+        })
+            .filter(Boolean);
+        if (parts.length > 0) {
+            return parts.join('\n');
+        }
+    }
+    return JSON.stringify(payload);
+}
+function mapSlashCommand(command) {
+    return {
+        name: command.name,
+        description: command.description,
+        argumentHint: command.argumentHint,
+        source: 'sdk',
+    };
+}
+function mapAgent(agent) {
+    return {
+        name: agent.name,
+        description: agent.description,
+        model: agent.model,
+        source: 'sdk',
+    };
+}

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

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

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

@@ -0,0 +1,23 @@
+export class ClaudeSessionService {
+    sdkAdapter;
+    metadataService;
+    constructor(sdkAdapter, metadataService) {
+        this.sdkAdapter = sdkAdapter;
+        this.metadataService = metadataService;
+    }
+    runTask(input, onEvent) {
+        return this.sdkAdapter.runSession(input, onEvent);
+    }
+    listSessions(cwd) {
+        return this.sdkAdapter.listSavedSessions(cwd);
+    }
+    getTranscript(sessionId, cwd) {
+        return this.sdkAdapter.getTranscript(sessionId, cwd);
+    }
+    inspectRepository(cwd, options) {
+        return this.metadataService.collect(cwd, options);
+    }
+    probeCapabilities(cwd) {
+        return this.sdkAdapter.probeCapabilities(cwd);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+import type { Plugin } from '@opencode-ai/plugin';
+export { ClaudeAgentSdkAdapter } from './claude/claude-agent-sdk-adapter.js';
+export { ClaudeSessionService } from './claude/claude-session.service.js';
+export { ManagerOrchestrator } from './manager/manager-orchestrator.js';
+export { TaskPlanner } from './manager/task-planner.js';
+export { ClaudeMetadataService } from './metadata/claude-metadata.service.js';
+export { RepoClaudeConfigReader } from './metadata/repo-claude-config-reader.js';
+export { getOrCreatePluginServices } from './plugin/service-factory.js';
+export { FileRunStateStore } from './state/file-run-state-store.js';
+export { WorktreeCoordinator } from './worktree/worktree-coordinator.js';
+import { ClaudeManagerPlugin } from './plugin/claude-manager.plugin.js';
+export type { ClaudeCapabilitySnapshot, ClaudeMetadataSnapshot, ClaudeSessionRunResult, ClaudeSessionSummary, ClaudeSessionTranscriptMessage, ManagerRunRecord, ManagerRunResult, ManagerTaskRequest, ManagerPromptRegistry, RunClaudeSessionInput, } from './types/contracts.js';
+export { ClaudeManagerPlugin };
+export declare const plugin: Plugin;

package/dist/index.js

@@ -0,0 +1,12 @@
+export { ClaudeAgentSdkAdapter } from './claude/claude-agent-sdk-adapter.js';
+export { ClaudeSessionService } from './claude/claude-session.service.js';
+export { ManagerOrchestrator } from './manager/manager-orchestrator.js';
+export { TaskPlanner } from './manager/task-planner.js';
+export { ClaudeMetadataService } from './metadata/claude-metadata.service.js';
+export { RepoClaudeConfigReader } from './metadata/repo-claude-config-reader.js';
+export { getOrCreatePluginServices } from './plugin/service-factory.js';
+export { FileRunStateStore } from './state/file-run-state-store.js';
+export { WorktreeCoordinator } from './worktree/worktree-coordinator.js';
+import { ClaudeManagerPlugin } from './plugin/claude-manager.plugin.js';
+export { ClaudeManagerPlugin };
+export const plugin = ClaudeManagerPlugin;

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

@@ -0,0 +1,18 @@
+import type { ClaudeSessionService } from '../claude/claude-session.service.js';
+import type { FileRunStateStore } from '../state/file-run-state-store.js';
+import type { ManagerRunRecord, ManagerRunResult, ManagerTaskRequest } from '../types/contracts.js';
+import type { WorktreeCoordinator } from '../worktree/worktree-coordinator.js';
+import type { TaskPlanner } from './task-planner.js';
+export declare class ManagerOrchestrator {
+    private readonly sessionService;
+    private readonly stateStore;
+    private readonly worktreeCoordinator;
+    private readonly taskPlanner;
+    constructor(sessionService: ClaudeSessionService, stateStore: FileRunStateStore, worktreeCoordinator: WorktreeCoordinator, taskPlanner: TaskPlanner);
+    run(request: ManagerTaskRequest): Promise<ManagerRunResult>;
+    listRuns(cwd: string): Promise<ManagerRunRecord[]>;
+    getRun(cwd: string, runId: string): Promise<ManagerRunRecord | null>;
+    cleanupRunWorktrees(cwd: string, runId: string): Promise<ManagerRunRecord | null>;
+    private executePlan;
+    private patchSession;
+}

package/dist/manager/manager-orchestrator.js

@@ -0,0 +1,186 @@
+import { randomUUID } from 'node:crypto';
+import { managerPromptRegistry } from '../prompts/registry.js';
+export class ManagerOrchestrator {
+    sessionService;
+    stateStore;
+    worktreeCoordinator;
+    taskPlanner;
+    constructor(sessionService, stateStore, worktreeCoordinator, taskPlanner) {
+        this.sessionService = sessionService;
+        this.stateStore = stateStore;
+        this.worktreeCoordinator = worktreeCoordinator;
+        this.taskPlanner = taskPlanner;
+    }
+    async run(request) {
+        const mode = request.mode ?? 'auto';
+        const maxSubagents = Math.max(1, request.maxSubagents ?? 3);
+        const useWorktrees = request.useWorktrees ?? maxSubagents > 1;
+        const includeProjectSettings = request.includeProjectSettings ?? true;
+        const metadata = await this.sessionService.inspectRepository(request.cwd);
+        const plans = this.taskPlanner.plan(request.task, mode, maxSubagents);
+        const runId = randomUUID();
+        const createdAt = new Date().toISOString();
+        const assignments = await Promise.all(plans.map((plan) => this.worktreeCoordinator.prepareAssignment({
+            cwd: request.cwd,
+            runId,
+            title: plan.title,
+            useWorktree: useWorktrees && plans.length > 1,
+        })));
+        const plannedAssignments = plans.map((plan, index) => ({
+            plan,
+            assignment: assignments[index],
+        }));
+        const runRecord = {
+            id: runId,
+            cwd: request.cwd,
+            task: request.task,
+            mode,
+            useWorktrees,
+            includeProjectSettings,
+            status: 'running',
+            createdAt,
+            updatedAt: createdAt,
+            metadata,
+            sessions: plannedAssignments.map(({ plan, assignment }) => createManagedSessionRecord(plan, assignment.cwd, assignment)),
+        };
+        await this.stateStore.saveRun(runRecord);
+        const canRunInParallel = plannedAssignments.every(({ assignment }) => assignment.mode === 'git-worktree');
+        const settledResults = canRunInParallel
+            ? await Promise.allSettled(plannedAssignments.map(({ plan, assignment }) => this.executePlan({
+                request,
+                runId,
+                plan,
+                assignment,
+                includeProjectSettings,
+            })))
+            : await runSequentially(plannedAssignments.map(({ plan, assignment }) => () => this.executePlan({
+                request,
+                runId,
+                plan,
+                assignment,
+                includeProjectSettings,
+            })));
+        const failedResult = settledResults.find((result) => result.status === 'rejected');
+        const finalRun = await this.stateStore.updateRun(request.cwd, runId, (currentRun) => ({
+            ...currentRun,
+            status: failedResult ? 'failed' : 'completed',
+            updatedAt: new Date().toISOString(),
+            finalSummary: summarizeRun(currentRun.sessions),
+        }));
+        return { run: finalRun };
+    }
+    listRuns(cwd) {
+        return this.stateStore.listRuns(cwd);
+    }
+    getRun(cwd, runId) {
+        return this.stateStore.getRun(cwd, runId);
+    }
+    async cleanupRunWorktrees(cwd, runId) {
+        const run = await this.stateStore.getRun(cwd, runId);
+        if (!run) {
+            return null;
+        }
+        for (const session of run.sessions) {
+            if (session.worktreeMode !== 'git-worktree') {
+                continue;
+            }
+            await this.worktreeCoordinator.cleanupAssignment({
+                mode: 'git-worktree',
+                cwd: session.cwd,
+                rootCwd: run.cwd,
+                branchName: session.branchName,
+            });
+        }
+        return run;
+    }
+    async executePlan(input) {
+        const { request, runId, plan, assignment, includeProjectSettings } = input;
+        await this.patchSession(request.cwd, runId, plan.id, (session) => ({
+            ...session,
+            status: 'running',
+        }));
+        try {
+            const sessionResult = await this.sessionService.runTask({
+                cwd: assignment.cwd,
+                prompt: buildWorkerPrompt(plan.prompt, request.task),
+                systemPrompt: managerPromptRegistry.subagentSystemPrompt,
+                model: request.model,
+                includePartialMessages: true,
+                settingSources: includeProjectSettings ? ['project', 'local'] : [],
+            }, async (event) => {
+                await this.patchSession(request.cwd, runId, plan.id, (session) => ({
+                    ...session,
+                    claudeSessionId: event.sessionId ?? session.claudeSessionId,
+                    events: [...session.events, compactEvent(event)],
+                }));
+            });
+            await this.patchSession(request.cwd, runId, plan.id, (session) => ({
+                ...session,
+                status: 'completed',
+                claudeSessionId: sessionResult.sessionId,
+                finalText: sessionResult.finalText,
+                turns: sessionResult.turns,
+                totalCostUsd: sessionResult.totalCostUsd,
+            }));
+        }
+        catch (error) {
+            await this.patchSession(request.cwd, runId, plan.id, (session) => ({
+                ...session,
+                status: 'failed',
+                error: error instanceof Error ? error.message : String(error),
+            }));
+            throw error;
+        }
+    }
+    async patchSession(cwd, runId, sessionId, update) {
+        await this.stateStore.updateRun(cwd, runId, (run) => ({
+            ...run,
+            updatedAt: new Date().toISOString(),
+            sessions: run.sessions.map((session) => session.id === sessionId ? update(session) : session),
+        }));
+    }
+}
+function createManagedSessionRecord(plan, cwd, assignment) {
+    return {
+        id: plan.id,
+        title: plan.title,
+        prompt: plan.prompt,
+        status: 'pending',
+        cwd,
+        worktreeMode: assignment.mode,
+        branchName: assignment.branchName,
+        events: [],
+    };
+}
+function buildWorkerPrompt(subtaskPrompt, parentTask) {
+    return [
+        'You are executing a delegated Claude Code subtask.',
+        `Parent task: ${parentTask}`,
+        `Assigned subtask: ${subtaskPrompt}`,
+        'Stay within scope, finish the requested work, and end with a concise verification summary.',
+    ].join('\n\n');
+}
+function summarizeRun(sessions) {
+    return sessions
+        .map((session) => `${session.title}: ${session.finalText ?? session.error ?? session.status}`)
+        .join('\n');
+}
+function compactEvent(event) {
+    return {
+        ...event,
+        text: event.text.slice(0, 4000),
+    };
+}
+async function runSequentially(tasks) {
+    const results = [];
+    for (const task of tasks) {
+        try {
+            await task();
+            results.push({ status: 'fulfilled', value: undefined });
+        }
+        catch (error) {
+            results.push({ status: 'rejected', reason: error });
+        }
+    }
+    return results;
+}

package/dist/manager/task-planner.d.ts

@@ -0,0 +1,5 @@
+import type { ManagedSubtaskPlan, ManagerRunMode } from '../types/contracts.js';
+export declare class TaskPlanner {
+    plan(task: string, mode: ManagerRunMode, maxSubagents: number): ManagedSubtaskPlan[];
+    private createPlan;
+}