@doingdev/opencode-claude-manager-plugin 0.1.19 → 0.1.21

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

@@ -1,578 +0,0 @@
-import { tool } from '@opencode-ai/plugin';
-import { managerPromptRegistry } from '../prompts/registry.js';
-import { getOrCreatePluginServices } from './service-factory.js';
-const MANAGER_TOOL_IDS = [
-    'claude_manager_send',
-    'claude_manager_git_diff',
-    'claude_manager_git_commit',
-    'claude_manager_git_reset',
-    'claude_manager_clear',
-    'claude_manager_status',
-    'claude_manager_metadata',
-    'claude_manager_sessions',
-    'claude_manager_runs',
-    'claude_manager_approval_policy',
-    'claude_manager_approval_decisions',
-    'claude_manager_approval_update',
-];
-export const ClaudeManagerPlugin = async ({ worktree }) => {
-    const services = getOrCreatePluginServices(worktree);
-    return {
-        config: async (config) => {
-            config.agent ??= {};
-            config.command ??= {};
-            config.permission ??= {};
-            const globalPermissions = config.permission;
-            const managerPermissions = {};
-            const researchPermissions = {};
-            for (const toolId of MANAGER_TOOL_IDS) {
-                globalPermissions[toolId] ??= 'deny';
-                managerPermissions[toolId] = 'allow';
-                // Research agent can inspect but not send or modify
-                researchPermissions[toolId] =
-                    toolId === 'claude_manager_send' ||
-                        toolId === 'claude_manager_git_commit' ||
-                        toolId === 'claude_manager_git_reset' ||
-                        toolId === 'claude_manager_clear' ||
-                        toolId === 'claude_manager_approval_update'
-                        ? 'deny'
-                        : 'allow';
-            }
-            config.agent['claude-manager'] ??= {
-                description: 'Primary agent that operates Claude Code through a persistent session, reviews work via git diff, and commits/resets changes.',
-                mode: 'primary',
-                color: '#D97757',
-                permission: {
-                    '*': 'deny',
-                    read: 'allow',
-                    grep: 'allow',
-                    glob: 'allow',
-                    codesearch: 'allow',
-                    webfetch: 'allow',
-                    websearch: 'allow',
-                    todowrite: 'allow',
-                    todoread: 'allow',
-                    question: 'allow',
-                    ...managerPermissions,
-                },
-                prompt: managerPromptRegistry.managerSystemPrompt,
-            };
-            config.agent['claude-manager-research'] ??= {
-                description: 'Subagent that inspects Claude metadata, prior sessions, and manager runs without changing repository state.',
-                mode: 'subagent',
-                color: 'info',
-                permission: {
-                    '*': 'deny',
-                    ...researchPermissions,
-                },
-                prompt: [
-                    'Focus on inspection and summarization.',
-                    'Use claude_manager_status, claude_manager_metadata, claude_manager_sessions, and claude_manager_runs to gather information.',
-                ].join(' '),
-            };
-            config.command['claude-run'] ??= {
-                description: 'Send a task to the persistent Claude Code session.',
-                agent: 'claude-manager',
-                subtask: true,
-                template: [
-                    'Use claude_manager_send to send the following task to Claude Code:',
-                    '$ARGUMENTS',
-                    'After it completes, review the result and use claude_manager_git_diff if changes were expected. Commit or reset accordingly.',
-                ].join('\n\n'),
-            };
-            config.command['claude-metadata'] ??= {
-                description: 'Inspect bundled Claude commands, skills, hooks, and agents.',
-                agent: 'claude-manager-research',
-                subtask: true,
-                template: [
-                    'Use claude_manager_metadata to inspect the current repository.',
-                    'Summarize Claude commands, skills, hooks, discovered agents, and important config files.',
-                ].join(' '),
-            };
-            config.command['claude-sessions'] ??= {
-                description: 'Inspect Claude session history and manager run records.',
-                agent: 'claude-manager-research',
-                subtask: true,
-                template: [
-                    'Use claude_manager_sessions and claude_manager_runs to inspect recent Claude activity for this repository.',
-                    'If the user provided extra arguments, use them to focus the inspection:',
-                    '$ARGUMENTS',
-                ].join('\n\n'),
-            };
-        },
-        'command.execute.before': async (input, output) => {
-            const commandText = buildCommandText(input.command, input.arguments);
-            if (commandText) {
-                output.parts = rewriteCommandParts(output.parts, commandText);
-            }
-        },
-        tool: {
-            claude_manager_send: tool({
-                description: 'Send a message to the persistent Claude Code session. ' +
-                    'Auto-creates a session on first call. Resumes the existing session on subsequent calls. ' +
-                    'Returns the assistant response and current context health snapshot. ' +
-                    'Use mode "plan" for read-only investigation and planning (no edits), ' +
-                    'or "free" (default) for normal execution with edit permissions.',
-                args: {
-                    message: tool.schema.string().min(1),
-                    model: tool.schema.string().optional(),
-                    mode: tool.schema.enum(['plan', 'free']).default('free'),
-                    cwd: tool.schema.string().optional(),
-                },
-                async execute(args, context) {
-                    const cwd = args.cwd ?? context.worktree;
-                    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: {
-                            sessionId: services.manager.getStatus().sessionId,
-                            prompt: promptPreview,
-                        },
-                    });
-                    let turnsSoFar = 0;
-                    let costSoFar = 0;
-                    const result = await services.manager.sendMessage(cwd, args.message, { model: args.model, mode: args.mode, abortSignal: context.abort }, (event) => {
-                        if (event.turns !== undefined) {
-                            turnsSoFar = event.turns;
-                        }
-                        if (event.totalCostUsd !== undefined) {
-                            costSoFar = event.totalCostUsd;
-                        }
-                        const costLabel = `$${costSoFar.toFixed(4)}`;
-                        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}... (${turnsSoFar} turns, ${costLabel})`,
-                                metadata: {
-                                    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... (${turnsSoFar} turns, ${costLabel})`,
-                                metadata: {
-                                    sessionId: event.sessionId,
-                                    type: event.type,
-                                    thinking: thinkingPreview,
-                                },
-                            });
-                        }
-                        else if (event.type === 'init') {
-                            context.metadata({
-                                title: `Claude Code: Session started`,
-                                metadata: {
-                                    sessionId: event.sessionId,
-                                    prompt: promptPreview,
-                                },
-                            });
-                        }
-                        else if (event.type === 'user') {
-                            const preview = event.text.length > 200
-                                ? event.text.slice(0, 200) + '...'
-                                : event.text;
-                            context.metadata({
-                                title: `Claude Code: Tool result (${turnsSoFar} turns, ${costLabel})`,
-                                metadata: {
-                                    sessionId: event.sessionId,
-                                    type: event.type,
-                                    output: preview,
-                                },
-                            });
-                        }
-                        else if (event.type === 'tool_progress') {
-                            let toolName = 'tool';
-                            let elapsed = 0;
-                            try {
-                                const parsed = JSON.parse(event.text);
-                                toolName = parsed.name ?? 'tool';
-                                elapsed = parsed.elapsed ?? 0;
-                            }
-                            catch {
-                                // ignore
-                            }
-                            context.metadata({
-                                title: `Claude Code: ${toolName} running ${elapsed > 0 ? `(${elapsed.toFixed(0)}s)` : ''}... (${turnsSoFar} turns, ${costLabel})`,
-                                metadata: {
-                                    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 (${turnsSoFar} turns, ${costLabel})`,
-                                metadata: {
-                                    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... (${turnsSoFar} turns, ${costLabel})`,
-                                metadata: {
-                                    sessionId: event.sessionId,
-                                    type: event.type,
-                                    delta,
-                                },
-                            });
-                        }
-                        else if (event.type === 'error') {
-                            context.metadata({
-                                title: `Claude Code: Error`,
-                                metadata: {
-                                    sessionId: event.sessionId,
-                                    error: event.text.slice(0, 200),
-                                },
-                            });
-                        }
-                    });
-                    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: { sessionId: result.sessionId, contextWarning },
-                        });
-                    }
-                    else {
-                        context.metadata({
-                            title: `Claude Code: Complete (${turns} turns, ${costLabel})`,
-                            metadata: { sessionId: result.sessionId },
-                        });
-                    }
-                    // Fetch recent tool output from the JSONL file for richer feedback.
-                    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,
-                        context: result.context,
-                        contextWarning,
-                        toolOutputs: toolOutputs.length > 0 ? toolOutputs : undefined,
-                    }, null, 2);
-                },
-            }),
-            claude_manager_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);
-                },
-            }),
-            claude_manager_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);
-                },
-            }),
-            claude_manager_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);
-                },
-            }),
-            claude_manager_clear: tool({
-                description: 'Clear the active Claude Code session. The next send will start a fresh session. ' +
-                    'Use when context is full, the session is confused, or starting a different 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 });
-                },
-            }),
-            claude_manager_status: tool({
-                description: 'Get the current persistent session status: context usage %, turns, cost, active 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);
-                },
-            }),
-            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. ' +
-                    'When sessionId is provided, returns both SDK transcript and local manager events.',
-                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);
-                },
-            }),
-            claude_manager_runs: tool({
-                description: 'List persistent manager run records.',
-                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_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);
-                },
-            }),
-            claude_manager_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);
-                },
-            }),
-            claude_manager_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) {
-    context.metadata({ title, metadata });
-}
-function buildCommandText(command, rawArguments) {
-    const argumentsText = rawArguments.trim();
-    if (command === 'claude-run') {
-        return [
-            'Use `claude_manager_send` to send the following task to Claude Code:',
-            argumentsText
-                ? argumentsText
-                : 'Inspect the current repository and wait for follow-up instructions.',
-            'After it completes, review the result. If code changes were expected, use `claude_manager_git_diff` to review, then `claude_manager_git_commit` or `claude_manager_git_reset` accordingly.',
-        ].join('\n\n');
-    }
-    if (command === 'claude-metadata') {
-        return [
-            'Call `claude_manager_metadata` immediately for the current repository.',
-            argumentsText ? `Focus: ${argumentsText}` : '',
-            'Then summarize the discovered Claude commands, skills, hooks, agents, and config files briefly.',
-        ]
-            .filter(Boolean)
-            .join('\n\n');
-    }
-    if (command === 'claude-sessions') {
-        return [
-            'Call `claude_manager_sessions` and `claude_manager_runs` immediately for the current repository.',
-            argumentsText ? `Focus: ${argumentsText}` : '',
-            'Then summarize the most relevant recent Claude activity briefly.',
-        ]
-            .filter(Boolean)
-            .join('\n\n');
-    }
-    return null;
-}
-function rewriteCommandParts(parts, text) {
-    let hasRewrittenText = false;
-    return parts.map((part) => {
-        if (part.type !== 'text' || hasRewrittenText) {
-            return part;
-        }
-        hasRewrittenText = true;
-        return { ...part, text };
-    });
-}
-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));
-}

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

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

@@ -1,41 +0,0 @@
-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 { 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 { 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 metadataService = new ClaudeMetadataService(new RepoClaudeConfigReader(), sdkAdapter);
-    const sessionService = new ClaudeSessionService(sdkAdapter, metadataService);
-    const contextTracker = new ContextTracker();
-    const sessionController = new SessionController(sdkAdapter, contextTracker, managerPromptRegistry.claudeCodeSessionPrompt, 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/state/file-run-state-store.d.ts

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