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

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

@@ -1,73 +0,0 @@
-import type { ClaudeSessionEvent, ClaudeSessionRunResult, PersistentRunRecord, PersistentRunResult, SessionContextSnapshot, GitDiffResult, GitOperationResult } from '../types/contracts.js';
-import type { ClaudeSessionEventHandler } from '../claude/claude-agent-sdk-adapter.js';
-import type { FileRunStateStore } from '../state/file-run-state-store.js';
-import type { TranscriptStore } from '../state/transcript-store.js';
-import type { SessionController } from './session-controller.js';
-import type { GitOperations } from './git-operations.js';
-import type { ContextTracker } from './context-tracker.js';
-type PersistentManagerProgressHandler = (run: PersistentRunRecord) => void | Promise<void>;
-export declare class PersistentManager {
-    private readonly sessionController;
-    private readonly gitOps;
-    private readonly stateStore;
-    private readonly contextTracker;
-    private readonly transcriptStore;
-    constructor(sessionController: SessionController, gitOps: GitOperations, stateStore: FileRunStateStore, contextTracker: ContextTracker, transcriptStore: TranscriptStore);
-    /**
-     * Send a message to the persistent Claude Code session.
-     * Creates a new session if none exists.
-     */
-    sendMessage(cwd: string, message: string, options?: {
-        model?: string;
-        mode?: 'plan' | 'free';
-        abortSignal?: AbortSignal;
-    }, onEvent?: ClaudeSessionEventHandler): Promise<{
-        sessionId: string | undefined;
-        finalText: string;
-        turns?: number;
-        totalCostUsd?: number;
-        context: SessionContextSnapshot;
-    }>;
-    /**
-     * Get the current git diff.
-     */
-    gitDiff(): Promise<GitDiffResult>;
-    /**
-     * Commit all current changes.
-     */
-    gitCommit(message: string): Promise<GitOperationResult>;
-    /**
-     * Hard reset to discard all uncommitted changes.
-     */
-    gitReset(): Promise<GitOperationResult>;
-    /**
-     * Get current session status and context health.
-     */
-    getStatus(): SessionContextSnapshot;
-    /**
-     * Clear the active session. Next send creates a fresh one.
-     */
-    clearSession(cwd: string): Promise<string | null>;
-    /**
-     * Compact the current session to free context.
-     */
-    compactSession(cwd: string, onEvent?: ClaudeSessionEventHandler): Promise<ClaudeSessionRunResult>;
-    /**
-     * Read persisted transcript events for a session.
-     */
-    getTranscriptEvents(cwd: string, sessionId: string): Promise<ClaudeSessionEvent[]>;
-    /**
-     * Execute a full task with run tracking.
-     * Creates a run record, sends the message, and persists the result.
-     */
-    executeTask(cwd: string, task: string, options?: {
-        model?: string;
-    }, onProgress?: PersistentManagerProgressHandler): Promise<PersistentRunResult>;
-    /**
-     * Try to restore session state from disk on startup.
-     */
-    tryRestore(cwd: string): Promise<boolean>;
-    listRuns(cwd: string): Promise<PersistentRunRecord[]>;
-    getRun(cwd: string, runId: string): Promise<PersistentRunRecord | null>;
-}
-export {};

package/dist/manager/persistent-manager.js

@@ -1,167 +0,0 @@
-import { randomUUID } from 'node:crypto';
-export class PersistentManager {
-    sessionController;
-    gitOps;
-    stateStore;
-    contextTracker;
-    transcriptStore;
-    constructor(sessionController, gitOps, stateStore, contextTracker, transcriptStore) {
-        this.sessionController = sessionController;
-        this.gitOps = gitOps;
-        this.stateStore = stateStore;
-        this.contextTracker = contextTracker;
-        this.transcriptStore = transcriptStore;
-    }
-    /**
-     * Send a message to the persistent Claude Code session.
-     * Creates a new session if none exists.
-     */
-    async sendMessage(cwd, message, options, onEvent) {
-        const result = await this.sessionController.sendMessage(cwd, message, options, onEvent);
-        if (result.sessionId && result.events.length > 0) {
-            await this.transcriptStore.appendEvents(cwd, result.sessionId, result.events);
-        }
-        return {
-            sessionId: result.sessionId,
-            finalText: result.finalText,
-            turns: result.turns,
-            totalCostUsd: result.totalCostUsd,
-            context: this.sessionController.getContextSnapshot(),
-        };
-    }
-    /**
-     * Get the current git diff.
-     */
-    async gitDiff() {
-        return this.gitOps.diff();
-    }
-    /**
-     * Commit all current changes.
-     */
-    async gitCommit(message) {
-        return this.gitOps.commit(message);
-    }
-    /**
-     * Hard reset to discard all uncommitted changes.
-     */
-    async gitReset() {
-        return this.gitOps.resetHard();
-    }
-    /**
-     * Get current session status and context health.
-     */
-    getStatus() {
-        return this.sessionController.getContextSnapshot();
-    }
-    /**
-     * Clear the active session. Next send creates a fresh one.
-     */
-    async clearSession(cwd) {
-        return this.sessionController.clearSession(cwd);
-    }
-    /**
-     * Compact the current session to free context.
-     */
-    async compactSession(cwd, onEvent) {
-        const result = await this.sessionController.compactSession(cwd, onEvent);
-        if (result.sessionId && result.events.length > 0) {
-            await this.transcriptStore.appendEvents(cwd, result.sessionId, result.events);
-        }
-        return result;
-    }
-    /**
-     * Read persisted transcript events for a session.
-     */
-    getTranscriptEvents(cwd, sessionId) {
-        return this.transcriptStore.readEvents(cwd, sessionId);
-    }
-    /**
-     * Execute a full task with run tracking.
-     * Creates a run record, sends the message, and persists the result.
-     */
-    async executeTask(cwd, task, options, onProgress) {
-        const runId = randomUUID();
-        const createdAt = new Date().toISOString();
-        const runRecord = {
-            id: runId,
-            cwd,
-            task,
-            status: 'running',
-            createdAt,
-            updatedAt: createdAt,
-            sessionId: this.sessionController.sessionId,
-            sessionHistory: [],
-            messages: [
-                {
-                    timestamp: createdAt,
-                    direction: 'sent',
-                    text: task,
-                },
-            ],
-            actions: [],
-            commits: [],
-            context: this.sessionController.getContextSnapshot(),
-        };
-        await this.stateStore.saveRun(runRecord);
-        await onProgress?.(runRecord);
-        try {
-            const result = await this.sessionController.sendMessage(cwd, task, options, async (event) => {
-                // Update run record with progress events
-                const currentRun = await this.stateStore.getRun(cwd, runId);
-                if (currentRun) {
-                    const updated = {
-                        ...currentRun,
-                        updatedAt: new Date().toISOString(),
-                        sessionId: event.sessionId ?? currentRun.sessionId,
-                        context: this.sessionController.getContextSnapshot(),
-                    };
-                    await this.stateStore.saveRun(updated);
-                    await onProgress?.(updated);
-                }
-            });
-            const completedRun = await this.stateStore.updateRun(cwd, runId, (run) => ({
-                ...run,
-                status: 'completed',
-                updatedAt: new Date().toISOString(),
-                sessionId: result.sessionId ?? run.sessionId,
-                messages: [
-                    ...run.messages,
-                    {
-                        timestamp: new Date().toISOString(),
-                        direction: 'received',
-                        text: result.finalText,
-                        turns: result.turns,
-                        totalCostUsd: result.totalCostUsd,
-                        inputTokens: result.inputTokens,
-                        outputTokens: result.outputTokens,
-                    },
-                ],
-                context: this.sessionController.getContextSnapshot(),
-                finalSummary: result.finalText,
-            }));
-            return { run: completedRun };
-        }
-        catch (error) {
-            const failedRun = await this.stateStore.updateRun(cwd, runId, (run) => ({
-                ...run,
-                status: 'failed',
-                updatedAt: new Date().toISOString(),
-                context: this.sessionController.getContextSnapshot(),
-                finalSummary: error instanceof Error ? error.message : String(error),
-            }));
-            return { run: failedRun };
-        }
-    }
-    /**
-     * Try to restore session state from disk on startup.
-     */
-    async tryRestore(cwd) {
-        return this.sessionController.tryRestore(cwd);
-    }
-    listRuns(cwd) {
-        return this.stateStore.listRuns(cwd);
-    }
-    getRun(cwd, runId) {
-        return this.stateStore.getRun(cwd, runId);
-    }
-}

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

@@ -1,45 +0,0 @@
-import type { ClaudeAgentSdkAdapter, ClaudeSessionEventHandler } from '../claude/claude-agent-sdk-adapter.js';
-import type { ClaudeSessionRunResult, SessionContextSnapshot, SessionMode } from '../types/contracts.js';
-import type { ContextTracker } from './context-tracker.js';
-export declare class SessionController {
-    private readonly sdkAdapter;
-    private readonly contextTracker;
-    private readonly sessionPrompt;
-    private readonly modePrefixes;
-    private activeSessionId;
-    constructor(sdkAdapter: ClaudeAgentSdkAdapter, contextTracker: ContextTracker, sessionPrompt: string, modePrefixes?: {
-        plan: string;
-        free: string;
-    });
-    get isActive(): boolean;
-    get sessionId(): string | null;
-    /**
-     * Send a message to the persistent session. Creates one if none exists.
-     * Returns the session result including usage data.
-     */
-    sendMessage(cwd: string, message: string, options?: {
-        model?: string;
-        effort?: 'low' | 'medium' | 'high' | 'max';
-        mode?: SessionMode;
-        settingSources?: Array<'user' | 'project' | 'local'>;
-        abortSignal?: AbortSignal;
-    }, onEvent?: ClaudeSessionEventHandler): Promise<ClaudeSessionRunResult>;
-    /**
-     * Send /compact to the current session to compress context.
-     */
-    compactSession(cwd: string, onEvent?: ClaudeSessionEventHandler): Promise<ClaudeSessionRunResult>;
-    /**
-     * Clear the current session. The next sendMessage will create a fresh one.
-     */
-    clearSession(cwd: string): Promise<string | null>;
-    /**
-     * Get current context tracking snapshot.
-     */
-    getContextSnapshot(): SessionContextSnapshot;
-    /**
-     * Try to restore active session from persisted state on startup.
-     */
-    tryRestore(cwd: string): Promise<boolean>;
-    private persistActiveSession;
-    private removeActiveSession;
-}

package/dist/manager/session-controller.js

@@ -1,147 +0,0 @@
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
-const ACTIVE_SESSION_FILE = '.claude-manager/active-session.json';
-export class SessionController {
-    sdkAdapter;
-    contextTracker;
-    sessionPrompt;
-    modePrefixes;
-    activeSessionId = null;
-    constructor(sdkAdapter, contextTracker, sessionPrompt, modePrefixes = {
-        plan: '',
-        free: '',
-    }) {
-        this.sdkAdapter = sdkAdapter;
-        this.contextTracker = contextTracker;
-        this.sessionPrompt = sessionPrompt;
-        this.modePrefixes = modePrefixes;
-    }
-    get isActive() {
-        return this.activeSessionId !== null;
-    }
-    get sessionId() {
-        return this.activeSessionId;
-    }
-    /**
-     * Send a message to the persistent session. Creates one if none exists.
-     * Returns the session result including usage data.
-     */
-    async sendMessage(cwd, message, options, onEvent) {
-        const mode = options?.mode ?? 'free';
-        const prefix = this.modePrefixes[mode];
-        const prompt = prefix ? `${prefix}\n\n${message}` : message;
-        const input = {
-            cwd,
-            prompt,
-            persistSession: true,
-            permissionMode: mode === 'plan' ? 'plan' : 'acceptEdits',
-            includePartialMessages: true,
-            model: options?.model,
-            effort: options?.effort,
-            settingSources: options?.settingSources ?? ['user', 'project', 'local'],
-            abortSignal: options?.abortSignal,
-        };
-        if (this.activeSessionId) {
-            // Resume existing session
-            input.resumeSessionId = this.activeSessionId;
-        }
-        else {
-            // New session — apply the expert operator system prompt and defaults
-            input.systemPrompt = this.sessionPrompt;
-            input.model ??= 'claude-opus-4-6';
-            input.effort ??= 'high';
-        }
-        const result = await this.sdkAdapter.runSession(input, onEvent);
-        // Track the session ID
-        if (result.sessionId) {
-            this.activeSessionId = result.sessionId;
-        }
-        // Update context tracking
-        this.contextTracker.recordResult({
-            sessionId: result.sessionId,
-            turns: result.turns,
-            totalCostUsd: result.totalCostUsd,
-            inputTokens: result.inputTokens,
-            outputTokens: result.outputTokens,
-            contextWindowSize: result.contextWindowSize,
-        });
-        // Persist active session state
-        await this.persistActiveSession(cwd);
-        return result;
-    }
-    /**
-     * Send /compact to the current session to compress context.
-     */
-    async compactSession(cwd, onEvent) {
-        if (!this.activeSessionId) {
-            throw new Error('No active session to compact');
-        }
-        const result = await this.sendMessage(cwd, '/compact', undefined, onEvent);
-        this.contextTracker.recordCompaction();
-        return result;
-    }
-    /**
-     * Clear the current session. The next sendMessage will create a fresh one.
-     */
-    async clearSession(cwd) {
-        const clearedId = this.activeSessionId;
-        this.activeSessionId = null;
-        this.contextTracker.reset();
-        await this.removeActiveSession(cwd);
-        return clearedId;
-    }
-    /**
-     * Get current context tracking snapshot.
-     */
-    getContextSnapshot() {
-        return this.contextTracker.snapshot();
-    }
-    /**
-     * Try to restore active session from persisted state on startup.
-     */
-    async tryRestore(cwd) {
-        const filePath = join(cwd, ACTIVE_SESSION_FILE);
-        try {
-            const raw = await readFile(filePath, 'utf-8');
-            const state = JSON.parse(raw);
-            if (state.sessionId && state.cwd === cwd) {
-                this.activeSessionId = state.sessionId;
-                this.contextTracker.restore(state);
-                return true;
-            }
-        }
-        catch {
-            // File doesn't exist or is corrupt — start fresh
-        }
-        return false;
-    }
-    async persistActiveSession(cwd) {
-        if (!this.activeSessionId) {
-            return;
-        }
-        const snap = this.contextTracker.snapshot();
-        const state = {
-            sessionId: this.activeSessionId,
-            cwd,
-            startedAt: new Date().toISOString(),
-            totalTurns: snap.totalTurns,
-            totalCostUsd: snap.totalCostUsd,
-            estimatedContextPercent: snap.estimatedContextPercent,
-            contextWindowSize: snap.contextWindowSize,
-            latestInputTokens: snap.latestInputTokens,
-        };
-        const filePath = join(cwd, ACTIVE_SESSION_FILE);
-        await mkdir(dirname(filePath), { recursive: true });
-        await writeFile(filePath, JSON.stringify(state, null, 2));
-    }
-    async removeActiveSession(cwd) {
-        const filePath = join(cwd, ACTIVE_SESSION_FILE);
-        try {
-            const { unlink } = await import('node:fs/promises');
-            await unlink(filePath);
-        }
-        catch {
-            // File doesn't exist — that's fine
-        }
-    }
-}

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

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

package/dist/manager/task-planner.js

@@ -1,15 +0,0 @@
-import { randomUUID } from 'node:crypto';
-export class TaskPlanner {
-    plan(tasks, maxSubagents) {
-        return tasks
-            .slice(0, maxSubagents)
-            .map((task, index) => this.createPlan(tasks.length === 1 ? 'Primary task' : `Subtask ${index + 1}`, task));
-    }
-    createPlan(title, prompt) {
-        return {
-            id: randomUUID(),
-            title,
-            prompt,
-        };
-    }
-}

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

@@ -1,12 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,154 +0,0 @@
-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-code-permission-bridge.d.ts

@@ -1,15 +0,0 @@
-import type { ToolContext } from '@opencode-ai/plugin';
-import type { ManagerSessionCanUseToolFactory } from '../types/contracts.js';
-export interface ClaudeCodePermissionBridge {
-    createCanUseTool: ManagerSessionCanUseToolFactory;
-}
-/**
- * Bridges Claude Agent SDK tool permission prompts to OpenCode `ToolContext.ask`.
- * Serializes concurrent asks: parallel manager sub-sessions share one OpenCode tool context.
- *
- * AskUserQuestion: OpenCode `ask` does not return selected labels. After approval we return
- * allow with answers set to each question's first option label so the session can proceed;
- * the UI should still show full choices — users needing a different option should answer via
- * the primary agent and re-run.
- */
-export declare function createClaudeCodePermissionBridge(context: ToolContext): ClaudeCodePermissionBridge;