@doingdev/opencode-claude-manager-plugin 0.1.0

package/dist/manager/task-planner.js

@@ -0,0 +1,42 @@
+import { randomUUID } from 'node:crypto';
+export class TaskPlanner {
+    plan(task, mode, maxSubagents) {
+        if (mode === 'single') {
+            return [this.createPlan('Primary task', task)];
+        }
+        const splitCandidates = extractTaskCandidates(task).slice(0, maxSubagents);
+        if (mode === 'split' && splitCandidates.length === 0) {
+            return [this.createPlan('Primary task', task)];
+        }
+        if (mode === 'auto' && splitCandidates.length < 2) {
+            return [this.createPlan('Primary task', task)];
+        }
+        if (splitCandidates.length === 0) {
+            return [this.createPlan('Primary task', task)];
+        }
+        return splitCandidates.map((candidate, index) => this.createPlan(`Subtask ${index + 1}`, candidate));
+    }
+    createPlan(title, prompt) {
+        return {
+            id: randomUUID(),
+            title,
+            prompt,
+        };
+    }
+}
+function extractTaskCandidates(task) {
+    const listMatches = task
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => /^(-|\*|\d+\.)\s+/.test(line))
+        .map((line) => line.replace(/^(-|\*|\d+\.)\s+/, '').trim())
+        .filter(Boolean);
+    if (listMatches.length > 0) {
+        return listMatches;
+    }
+    const sentenceMatches = task
+        .split(/;|\n{2,}/)
+        .map((part) => part.trim())
+        .filter((part) => part.length > 20);
+    return sentenceMatches.length > 1 ? sentenceMatches : [];
+}

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

@@ -0,0 +1,12 @@
+import type { ClaudeMetadataSnapshot, ClaudeSettingSource } from '../types/contracts.js';
+import type { ClaudeAgentSdkAdapter } from '../claude/claude-agent-sdk-adapter.js';
+import type { RepoClaudeConfigReader } from './repo-claude-config-reader.js';
+export declare class ClaudeMetadataService {
+    private readonly configReader;
+    private readonly sdkAdapter;
+    constructor(configReader: RepoClaudeConfigReader, sdkAdapter: ClaudeAgentSdkAdapter);
+    collect(cwd: string, options?: {
+        includeSdkProbe?: boolean;
+        settingSources?: ClaudeSettingSource[];
+    }): Promise<ClaudeMetadataSnapshot>;
+}

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

@@ -0,0 +1,38 @@
+export class ClaudeMetadataService {
+    configReader;
+    sdkAdapter;
+    constructor(configReader, sdkAdapter) {
+        this.configReader = configReader;
+        this.sdkAdapter = sdkAdapter;
+    }
+    async collect(cwd, options = {}) {
+        const baseSnapshot = await this.configReader.read(cwd);
+        if (!options.includeSdkProbe) {
+            return dedupeSnapshot(baseSnapshot);
+        }
+        const capabilities = await this.sdkAdapter.probeCapabilities(cwd, options.settingSources);
+        return dedupeSnapshot({
+            ...baseSnapshot,
+            commands: [...baseSnapshot.commands, ...capabilities.commands],
+            agents: capabilities.agents,
+        });
+    }
+}
+function dedupeSnapshot(snapshot) {
+    return {
+        ...snapshot,
+        commands: dedupeByName(snapshot.commands),
+        skills: dedupeByName(snapshot.skills),
+        hooks: dedupeByName(snapshot.hooks),
+        agents: dedupeByName(snapshot.agents),
+    };
+}
+function dedupeByName(items) {
+    const seen = new Map();
+    for (const item of items) {
+        if (!seen.has(item.name)) {
+            seen.set(item.name, item);
+        }
+    }
+    return [...seen.values()].sort((left, right) => left.name.localeCompare(right.name));
+}

package/dist/metadata/repo-claude-config-reader.d.ts

@@ -0,0 +1,7 @@
+import type { ClaudeMetadataSnapshot } from '../types/contracts.js';
+export declare class RepoClaudeConfigReader {
+    read(cwd: string): Promise<ClaudeMetadataSnapshot>;
+    private readSkills;
+    private readCommands;
+    private readSettings;
+}

package/dist/metadata/repo-claude-config-reader.js

@@ -0,0 +1,154 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import JSON5 from 'json5';
+export class RepoClaudeConfigReader {
+    async read(cwd) {
+        const claudeDirectory = path.join(cwd, '.claude');
+        const skillsDirectory = path.join(claudeDirectory, 'skills');
+        const commandsDirectory = path.join(claudeDirectory, 'commands');
+        const claudeMdCandidates = [
+            path.join(cwd, 'CLAUDE.md'),
+            path.join(claudeDirectory, 'CLAUDE.md'),
+        ];
+        const collectedAt = new Date().toISOString();
+        const [skills, commands, settingsResult, claudeMdPath] = await Promise.all([
+            this.readSkills(skillsDirectory),
+            this.readCommands(commandsDirectory),
+            this.readSettings(claudeDirectory),
+            findFirstExistingPath(claudeMdCandidates),
+        ]);
+        return {
+            collectedAt,
+            cwd,
+            commands: [...skillsToCommands(skills), ...commands],
+            skills,
+            hooks: settingsResult.hooks,
+            agents: [],
+            claudeMdPath: claudeMdPath ?? undefined,
+            settingsPaths: settingsResult.settingsPaths,
+        };
+    }
+    async readSkills(directory) {
+        if (!(await pathExists(directory))) {
+            return [];
+        }
+        const entries = await fs.readdir(directory, { withFileTypes: true });
+        const skills = await Promise.all(entries
+            .filter((entry) => entry.isDirectory())
+            .map(async (entry) => {
+            const skillPath = path.join(directory, entry.name, 'SKILL.md');
+            if (!(await pathExists(skillPath))) {
+                return null;
+            }
+            const content = await fs.readFile(skillPath, 'utf8');
+            return {
+                name: entry.name,
+                description: extractMarkdownDescription(content),
+                path: skillPath,
+                source: 'skill',
+            };
+        }));
+        return skills.filter((skill) => skill !== null);
+    }
+    async readCommands(directory) {
+        if (!(await pathExists(directory))) {
+            return [];
+        }
+        const commandFiles = await collectMarkdownFiles(directory);
+        const commands = await Promise.all(commandFiles.map(async (commandPath) => {
+            const content = await fs.readFile(commandPath, 'utf8');
+            return {
+                name: path.basename(commandPath, path.extname(commandPath)),
+                description: extractMarkdownDescription(content),
+                source: 'command',
+                path: commandPath,
+            };
+        }));
+        return commands.sort((left, right) => left.name.localeCompare(right.name));
+    }
+    async readSettings(claudeDirectory) {
+        const candidatePaths = [
+            path.join(claudeDirectory, 'settings.json'),
+            path.join(claudeDirectory, 'settings.local.json'),
+        ];
+        const settingsPaths = [];
+        const hooks = [];
+        for (const candidatePath of candidatePaths) {
+            if (!(await pathExists(candidatePath))) {
+                continue;
+            }
+            settingsPaths.push(candidatePath);
+            const content = await fs.readFile(candidatePath, 'utf8');
+            const parsed = JSON5.parse(content);
+            const hookEntries = Object.entries(parsed.hooks ?? {});
+            for (const [hookName, hookValue] of hookEntries) {
+                const hookMatchers = Array.isArray(hookValue) ? hookValue : [hookValue];
+                for (const hookMatcher of hookMatchers) {
+                    if (!hookMatcher || typeof hookMatcher !== 'object') {
+                        continue;
+                    }
+                    const matcher = typeof hookMatcher.matcher === 'string'
+                        ? hookMatcher.matcher
+                        : undefined;
+                    const commandCount = Array.isArray(hookMatcher.hooks)
+                        ? (hookMatcher.hooks?.length ?? 0)
+                        : 0;
+                    hooks.push({
+                        name: hookName,
+                        matcher,
+                        sourcePath: candidatePath,
+                        commandCount,
+                    });
+                }
+            }
+        }
+        return {
+            settingsPaths,
+            hooks,
+        };
+    }
+}
+function extractMarkdownDescription(markdown) {
+    const lines = markdown
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+    const descriptionLine = lines.find((line) => !line.startsWith('#') && !line.startsWith('---'));
+    return descriptionLine ?? 'No description provided.';
+}
+async function collectMarkdownFiles(directory) {
+    const entries = await fs.readdir(directory, { withFileTypes: true });
+    const files = await Promise.all(entries.map(async (entry) => {
+        const resolvedPath = path.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            return collectMarkdownFiles(resolvedPath);
+        }
+        return entry.name.endsWith('.md') ? [resolvedPath] : [];
+    }));
+    return files.flat();
+}
+async function pathExists(candidatePath) {
+    try {
+        await fs.access(candidatePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function findFirstExistingPath(candidatePaths) {
+    for (const candidatePath of candidatePaths) {
+        if (await pathExists(candidatePath)) {
+            return candidatePath;
+        }
+    }
+    return null;
+}
+function skillsToCommands(skills) {
+    return skills.map((skill) => ({
+        name: skill.name,
+        description: skill.description,
+        source: 'skill',
+        path: skill.path,
+    }));
+}

package/dist/plugin/claude-manager.plugin.d.ts

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

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

@@ -0,0 +1,102 @@
+import { tool } from '@opencode-ai/plugin';
+import { getOrCreatePluginServices } from './service-factory.js';
+export const ClaudeManagerPlugin = async ({ worktree }) => {
+    const services = getOrCreatePluginServices(worktree);
+    return {
+        tool: {
+            claude_manager_run: tool({
+                description: 'Delegate a task to Claude Code with optional subagents and worktrees.',
+                args: {
+                    task: tool.schema.string().min(1),
+                    mode: tool.schema.enum(['auto', 'single', 'split']).default('auto'),
+                    maxSubagents: tool.schema.number().int().min(1).max(8).default(3),
+                    useWorktrees: tool.schema.boolean().default(true),
+                    includeProjectSettings: tool.schema.boolean().default(true),
+                    model: tool.schema.string().optional(),
+                    cwd: tool.schema.string().optional(),
+                },
+                async execute(args, context) {
+                    annotateToolRun(context, 'Delegating task to Claude manager', {
+                        task: args.task,
+                        mode: args.mode,
+                    });
+                    const result = await services.manager.run({
+                        cwd: args.cwd ?? context.worktree,
+                        task: args.task,
+                        mode: args.mode,
+                        maxSubagents: args.maxSubagents,
+                        useWorktrees: args.useWorktrees,
+                        includeProjectSettings: args.includeProjectSettings,
+                        model: args.model,
+                    });
+                    return JSON.stringify(result.run, null, 2);
+                },
+            }),
+            claude_manager_metadata: tool({
+                description: 'Inspect Claude slash commands, skills, hooks, and repo settings.',
+                args: {
+                    cwd: tool.schema.string().optional(),
+                    includeSdkProbe: tool.schema.boolean().default(false),
+                },
+                async execute(args, context) {
+                    annotateToolRun(context, 'Collecting Claude metadata', {
+                        includeSdkProbe: args.includeSdkProbe,
+                    });
+                    const metadata = await services.sessions.inspectRepository(args.cwd ?? context.worktree, {
+                        includeSdkProbe: args.includeSdkProbe,
+                    });
+                    return JSON.stringify(metadata, null, 2);
+                },
+            }),
+            claude_manager_sessions: tool({
+                description: 'List Claude sessions or inspect a saved transcript.',
+                args: {
+                    cwd: tool.schema.string().optional(),
+                    sessionId: tool.schema.string().optional(),
+                },
+                async execute(args, context) {
+                    annotateToolRun(context, 'Inspecting Claude session history', {});
+                    if (args.sessionId) {
+                        const transcript = await services.sessions.getTranscript(args.sessionId, args.cwd ?? context.worktree);
+                        return JSON.stringify(transcript, null, 2);
+                    }
+                    const sessions = await services.sessions.listSessions(args.cwd ?? context.worktree);
+                    return JSON.stringify(sessions, null, 2);
+                },
+            }),
+            claude_manager_runs: tool({
+                description: 'List manager runs previously recorded for this repo.',
+                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);
+                },
+            }),
+            claude_manager_cleanup_run: tool({
+                description: 'Explicitly remove git worktrees created for a recorded manager run.',
+                args: {
+                    runId: tool.schema.string().min(1),
+                    cwd: tool.schema.string().optional(),
+                },
+                async execute(args, context) {
+                    annotateToolRun(context, 'Cleaning manager worktrees', {
+                        runId: args.runId,
+                    });
+                    const run = await services.manager.cleanupRunWorktrees(args.cwd ?? context.worktree, args.runId);
+                    return JSON.stringify(run, null, 2);
+                },
+            }),
+        },
+    };
+};
+function annotateToolRun(context, title, metadata) {
+    context.metadata({ title, metadata });
+}

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

@@ -0,0 +1,7 @@
+import { ClaudeSessionService } from '../claude/claude-session.service.js';
+import { ManagerOrchestrator } from '../manager/manager-orchestrator.js';
+export interface ClaudeManagerPluginServices {
+    manager: ManagerOrchestrator;
+    sessions: ClaudeSessionService;
+}
+export declare function getOrCreatePluginServices(worktree: string): ClaudeManagerPluginServices;

package/dist/plugin/service-factory.js

@@ -0,0 +1,25 @@
+import { ClaudeAgentSdkAdapter } from '../claude/claude-agent-sdk-adapter.js';
+import { ClaudeSessionService } from '../claude/claude-session.service.js';
+import { ManagerOrchestrator } from '../manager/manager-orchestrator.js';
+import { TaskPlanner } from '../manager/task-planner.js';
+import { ClaudeMetadataService } from '../metadata/claude-metadata.service.js';
+import { RepoClaudeConfigReader } from '../metadata/repo-claude-config-reader.js';
+import { FileRunStateStore } from '../state/file-run-state-store.js';
+import { WorktreeCoordinator } from '../worktree/worktree-coordinator.js';
+const serviceCache = new Map();
+export function getOrCreatePluginServices(worktree) {
+    const cachedServices = serviceCache.get(worktree);
+    if (cachedServices) {
+        return cachedServices;
+    }
+    const sdkAdapter = new ClaudeAgentSdkAdapter();
+    const metadataService = new ClaudeMetadataService(new RepoClaudeConfigReader(), sdkAdapter);
+    const sessionService = new ClaudeSessionService(sdkAdapter, metadataService);
+    const manager = new ManagerOrchestrator(sessionService, new FileRunStateStore(), new WorktreeCoordinator(), new TaskPlanner());
+    const services = {
+        manager,
+        sessions: sessionService,
+    };
+    serviceCache.set(worktree, services);
+    return services;
+}

package/dist/prompts/registry.d.ts

@@ -0,0 +1,2 @@
+import type { ManagerPromptRegistry } from '../types/contracts.js';
+export declare const managerPromptRegistry: ManagerPromptRegistry;

package/dist/prompts/registry.js

@@ -0,0 +1,11 @@
+export const managerPromptRegistry = {
+    managerSystemPrompt: [
+        'You are the OpenCode manager for Claude Code sessions.',
+        'Plan first, delegate carefully, and keep user-visible progress concise.',
+        'Prefer deterministic orchestration in code over prompt-only control flow.',
+    ].join(' '),
+    subagentSystemPrompt: [
+        'You are a Claude execution worker managed by OpenCode.',
+        'Stay within assigned scope, report blockers explicitly, and summarize changes with verification notes.',
+    ].join(' '),
+};

package/dist/state/file-run-state-store.d.ts

@@ -0,0 +1,14 @@
+import type { ManagerRunRecord } from '../types/contracts.js';
+export declare class FileRunStateStore {
+    private readonly baseDirectoryName;
+    private readonly writeQueues;
+    constructor(baseDirectoryName?: string);
+    saveRun(run: ManagerRunRecord): Promise<void>;
+    getRun(cwd: string, runId: string): Promise<ManagerRunRecord | null>;
+    listRuns(cwd: string): Promise<ManagerRunRecord[]>;
+    updateRun(cwd: string, runId: string, update: (run: ManagerRunRecord) => ManagerRunRecord): Promise<ManagerRunRecord>;
+    private getRunKey;
+    private getRunsDirectory;
+    private getRunPath;
+    private enqueueWrite;
+}

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

@@ -0,0 +1,97 @@
+import { randomUUID } from 'node:crypto';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+export class FileRunStateStore {
+    baseDirectoryName;
+    writeQueues = new Map();
+    constructor(baseDirectoryName = '.claude-manager') {
+        this.baseDirectoryName = baseDirectoryName;
+    }
+    async saveRun(run) {
+        await this.enqueueWrite(this.getRunKey(run.cwd, run.id), async () => {
+            const runPath = this.getRunPath(run.cwd, run.id);
+            await fs.mkdir(path.dirname(runPath), { recursive: true });
+            await writeJsonAtomically(runPath, run);
+        });
+    }
+    async getRun(cwd, runId) {
+        const runPath = this.getRunPath(cwd, runId);
+        try {
+            const content = await fs.readFile(runPath, 'utf8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            if (isFileNotFoundError(error)) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async listRuns(cwd) {
+        const runsDirectory = this.getRunsDirectory(cwd);
+        try {
+            const entries = await fs.readdir(runsDirectory);
+            const runs = await Promise.all(entries
+                .filter((entry) => entry.endsWith('.json'))
+                .map(async (entry) => {
+                const content = await fs.readFile(path.join(runsDirectory, entry), 'utf8');
+                return JSON.parse(content);
+            }));
+            return runs.sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+        }
+        catch (error) {
+            if (isFileNotFoundError(error)) {
+                return [];
+            }
+            throw error;
+        }
+    }
+    async updateRun(cwd, runId, update) {
+        return this.enqueueWrite(this.getRunKey(cwd, runId), async () => {
+            const existingRun = await this.getRun(cwd, runId);
+            if (!existingRun) {
+                throw new Error(`Run ${runId} does not exist.`);
+            }
+            const updatedRun = update(existingRun);
+            const runPath = this.getRunPath(cwd, runId);
+            await fs.mkdir(path.dirname(runPath), { recursive: true });
+            await writeJsonAtomically(runPath, updatedRun);
+            return updatedRun;
+        });
+    }
+    getRunKey(cwd, runId) {
+        return `${cwd}:${runId}`;
+    }
+    getRunsDirectory(cwd) {
+        return path.join(cwd, this.baseDirectoryName, 'runs');
+    }
+    getRunPath(cwd, runId) {
+        return path.join(this.getRunsDirectory(cwd), `${runId}.json`);
+    }
+    async enqueueWrite(key, operation) {
+        const previousOperation = this.writeQueues.get(key) ?? Promise.resolve();
+        const resultPromise = previousOperation
+            .catch(() => undefined)
+            .then(operation);
+        const settledPromise = resultPromise.then(() => undefined, () => undefined);
+        this.writeQueues.set(key, settledPromise);
+        try {
+            return await resultPromise;
+        }
+        finally {
+            if (this.writeQueues.get(key) === settledPromise) {
+                this.writeQueues.delete(key);
+            }
+        }
+    }
+}
+async function writeJsonAtomically(filePath, data) {
+    const tempPath = `${filePath}.${randomUUID()}.tmp`;
+    await fs.writeFile(tempPath, `${JSON.stringify(data, null, 2)}\n`, 'utf8');
+    await fs.rename(tempPath, filePath);
+}
+function isFileNotFoundError(error) {
+    return (error instanceof Error &&
+        'code' in error &&
+        error.code === 'ENOENT');
+}

package/dist/types/contracts.d.ts

@@ -0,0 +1,145 @@
+export interface ManagerPromptRegistry {
+    managerSystemPrompt: string;
+    subagentSystemPrompt: string;
+}
+export type ClaudeSettingSource = 'user' | 'project' | 'local';
+export interface ClaudeCommandMetadata {
+    name: string;
+    description: string;
+    argumentHint?: string;
+    source: 'sdk' | 'skill' | 'command';
+    path?: string;
+}
+export interface ClaudeSkillMetadata {
+    name: string;
+    description: string;
+    path: string;
+    source: 'skill' | 'command';
+}
+export interface ClaudeHookMetadata {
+    name: string;
+    matcher?: string;
+    sourcePath: string;
+    commandCount: number;
+}
+export interface ClaudeAgentMetadata {
+    name: string;
+    description: string;
+    model?: string;
+    source: 'sdk' | 'filesystem';
+}
+export interface ClaudeMetadataSnapshot {
+    collectedAt: string;
+    cwd: string;
+    commands: ClaudeCommandMetadata[];
+    skills: ClaudeSkillMetadata[];
+    hooks: ClaudeHookMetadata[];
+    agents: ClaudeAgentMetadata[];
+    claudeMdPath?: string;
+    settingsPaths: string[];
+}
+export interface ClaudeSessionEvent {
+    type: 'init' | 'assistant' | 'partial' | 'status' | 'system' | 'result' | 'error';
+    sessionId?: string;
+    text: string;
+    turns?: number;
+    totalCostUsd?: number;
+    rawType: string;
+}
+export interface RunClaudeSessionInput {
+    cwd: string;
+    prompt: string;
+    systemPrompt?: string;
+    model?: string;
+    permissionMode?: 'default' | 'acceptEdits' | 'plan' | 'dontAsk';
+    allowedTools?: string[];
+    disallowedTools?: string[];
+    continueSession?: boolean;
+    resumeSessionId?: string;
+    forkSession?: boolean;
+    persistSession?: boolean;
+    includePartialMessages?: boolean;
+    settingSources?: ClaudeSettingSource[];
+    maxTurns?: number;
+}
+export interface ClaudeSessionRunResult {
+    sessionId?: string;
+    events: ClaudeSessionEvent[];
+    finalText: string;
+    turns?: number;
+    totalCostUsd?: number;
+}
+export interface ClaudeSessionSummary {
+    sessionId: string;
+    summary: string;
+    cwd?: string;
+    gitBranch?: string;
+    createdAt?: number;
+    lastModified: number;
+}
+export interface ClaudeSessionTranscriptMessage {
+    role: 'user' | 'assistant';
+    sessionId: string;
+    messageId: string;
+    text: string;
+}
+export interface ClaudeCapabilitySnapshot {
+    commands: ClaudeCommandMetadata[];
+    agents: ClaudeAgentMetadata[];
+    models: string[];
+}
+export type ManagerRunMode = 'auto' | 'single' | 'split';
+export type ManagerRunStatus = 'pending' | 'running' | 'completed' | 'failed';
+export type WorktreeMode = 'shared-root' | 'git-worktree';
+export interface ManagedSubtaskPlan {
+    id: string;
+    title: string;
+    prompt: string;
+}
+export interface WorktreeAssignment {
+    mode: WorktreeMode;
+    cwd: string;
+    rootCwd: string;
+    branchName?: string;
+}
+export interface ManagedSessionRecord {
+    id: string;
+    title: string;
+    prompt: string;
+    status: ManagerRunStatus;
+    cwd: string;
+    worktreeMode: WorktreeMode;
+    branchName?: string;
+    claudeSessionId?: string;
+    finalText?: string;
+    turns?: number;
+    totalCostUsd?: number;
+    error?: string;
+    events: ClaudeSessionEvent[];
+}
+export interface ManagerRunRecord {
+    id: string;
+    cwd: string;
+    task: string;
+    mode: ManagerRunMode;
+    useWorktrees: boolean;
+    includeProjectSettings: boolean;
+    status: ManagerRunStatus;
+    createdAt: string;
+    updatedAt: string;
+    metadata: ClaudeMetadataSnapshot;
+    sessions: ManagedSessionRecord[];
+    finalSummary?: string;
+}
+export interface ManagerTaskRequest {
+    cwd: string;
+    task: string;
+    mode?: ManagerRunMode;
+    maxSubagents?: number;
+    useWorktrees?: boolean;
+    includeProjectSettings?: boolean;
+    model?: string;
+}
+export interface ManagerRunResult {
+    run: ManagerRunRecord;
+}

package/dist/types/contracts.js

@@ -0,0 +1 @@
+export {};