@doingdev/opencode-claude-manager-plugin 0.1.12 → 0.1.15

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

@@ -1,5 +1,6 @@
 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';
+import type { ToolApprovalManager } from './tool-approval-manager.js';
 export type ClaudeSessionEventHandler = (event: ClaudeSessionEvent) => void | Promise<void>;
 interface ClaudeAgentSdkFacade {
     query(params: {
@@ -15,7 +16,8 @@ interface ClaudeAgentSdkFacade {
 }
 export declare class ClaudeAgentSdkAdapter {
     private readonly sdkFacade;
-    constructor(sdkFacade?: ClaudeAgentSdkFacade);
+    private readonly approvalManager?;
+    constructor(sdkFacade?: ClaudeAgentSdkFacade, approvalManager?: ToolApprovalManager | undefined);
     runSession(input: RunClaudeSessionInput, onEvent?: ClaudeSessionEventHandler): Promise<ClaudeSessionRunResult>;
     listSavedSessions(cwd?: string): Promise<ClaudeSessionSummary[]>;
     getTranscript(sessionId: string, cwd?: string): Promise<ClaudeSessionTranscriptMessage[]>;

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

@@ -9,12 +9,27 @@ const TOOL_INPUT_PREVIEW_MAX = 2000;
 const USER_MESSAGE_MAX = 4000;
 export class ClaudeAgentSdkAdapter {
     sdkFacade;
-    constructor(sdkFacade = defaultFacade) {
+    approvalManager;
+    constructor(sdkFacade = defaultFacade, approvalManager) {
         this.sdkFacade = sdkFacade;
+        this.approvalManager = approvalManager;
     }
     async runSession(input, onEvent) {
         const options = this.buildOptions(input);
         const includePartials = options.includePartialMessages === true;
+        const abortController = new AbortController();
+        options.abortController = abortController;
+        const externalSignal = input.abortSignal;
+        let onAbort;
+        if (externalSignal) {
+            if (externalSignal.aborted) {
+                abortController.abort();
+            }
+            else {
+                onAbort = () => abortController.abort();
+                externalSignal.addEventListener('abort', onAbort, { once: true });
+            }
+        }
         const sessionQuery = this.sdkFacade.query({
             prompt: input.prompt,
             options,
@@ -58,6 +73,9 @@ export class ClaudeAgentSdkAdapter {
             }
         }
         finally {
+            if (onAbort && externalSignal) {
+                externalSignal.removeEventListener('abort', onAbort);
+            }
             sessionQuery.close();
         }
         return {
@@ -145,6 +163,15 @@ export class ClaudeAgentSdkAdapter {
         if (!input.resumeSessionId) {
             delete options.resume;
         }
+        if (this.approvalManager) {
+            const manager = this.approvalManager;
+            options.canUseTool = async (toolName, toolInput, opts) => {
+                return manager.evaluate(toolName, toolInput, {
+                    title: opts.title,
+                    agentID: opts.agentID,
+                });
+            };
+        }
         return options;
     }
 }

package/dist/claude/tool-approval-manager.d.ts

@@ -0,0 +1,27 @@
+import type { ToolApprovalDecision, ToolApprovalPolicy, ToolApprovalRule } from '../types/contracts.js';
+export declare class ToolApprovalManager {
+    private policy;
+    private decisions;
+    private readonly maxDecisions;
+    constructor(policy?: Partial<ToolApprovalPolicy>, maxDecisions?: number);
+    evaluate(toolName: string, input: Record<string, unknown>, options?: {
+        title?: string;
+        agentID?: string;
+    }): {
+        behavior: 'allow';
+    } | {
+        behavior: 'deny';
+        message: string;
+    };
+    getDecisions(limit?: number): ToolApprovalDecision[];
+    getDeniedDecisions(limit?: number): ToolApprovalDecision[];
+    clearDecisions(): void;
+    getPolicy(): ToolApprovalPolicy;
+    setPolicy(policy: ToolApprovalPolicy): void;
+    addRule(rule: ToolApprovalRule, position?: number): void;
+    removeRule(ruleId: string): boolean;
+    setDefaultAction(action: 'allow' | 'deny'): void;
+    setEnabled(enabled: boolean): void;
+    private findMatchingRule;
+    private recordDecision;
+}

package/dist/claude/tool-approval-manager.js

@@ -0,0 +1,232 @@
+const DEFAULT_MAX_DECISIONS = 500;
+const INPUT_PREVIEW_MAX = 300;
+function getDefaultRules() {
+    return [
+        // Safe read-only tools
+        {
+            id: 'allow-read',
+            toolPattern: 'Read',
+            action: 'allow',
+            description: 'Allow reading files',
+        },
+        {
+            id: 'allow-grep',
+            toolPattern: 'Grep',
+            action: 'allow',
+            description: 'Allow grep searches',
+        },
+        {
+            id: 'allow-glob',
+            toolPattern: 'Glob',
+            action: 'allow',
+            description: 'Allow glob file searches',
+        },
+        {
+            id: 'allow-ls',
+            toolPattern: 'LS',
+            action: 'allow',
+            description: 'Allow directory listing',
+        },
+        {
+            id: 'allow-list',
+            toolPattern: 'ListDirectory',
+            action: 'allow',
+            description: 'Allow listing directories',
+        },
+        // Edit tools
+        {
+            id: 'allow-edit',
+            toolPattern: 'Edit',
+            action: 'allow',
+            description: 'Allow file edits',
+        },
+        {
+            id: 'allow-multiedit',
+            toolPattern: 'MultiEdit',
+            action: 'allow',
+            description: 'Allow multi-edits',
+        },
+        {
+            id: 'allow-write',
+            toolPattern: 'Write',
+            action: 'allow',
+            description: 'Allow file writes',
+        },
+        {
+            id: 'allow-notebook',
+            toolPattern: 'NotebookEdit',
+            action: 'allow',
+            description: 'Allow notebook edits',
+        },
+        // Bash - deny dangerous patterns first, then allow the rest
+        {
+            id: 'deny-bash-rm-rf-root',
+            toolPattern: 'Bash',
+            inputPattern: 'rm -rf /',
+            action: 'deny',
+            denyMessage: 'Destructive rm -rf on root path is not allowed.',
+            description: 'Block rm -rf on root',
+        },
+        {
+            id: 'deny-bash-force-push',
+            toolPattern: 'Bash',
+            inputPattern: 'git push --force',
+            action: 'deny',
+            denyMessage: 'Force push is not allowed.',
+            description: 'Block git force push',
+        },
+        {
+            id: 'deny-bash-reset-hard',
+            toolPattern: 'Bash',
+            inputPattern: 'git reset --hard',
+            action: 'deny',
+            denyMessage: 'git reset --hard is not allowed from Claude Code. Use the manager git_reset tool instead.',
+            description: 'Block git reset --hard',
+        },
+        {
+            id: 'allow-bash',
+            toolPattern: 'Bash',
+            action: 'allow',
+            description: 'Allow bash commands (after dangerous patterns filtered)',
+        },
+        // Agent / misc
+        {
+            id: 'allow-agent',
+            toolPattern: 'Agent',
+            action: 'allow',
+            description: 'Allow agent delegation',
+        },
+        {
+            id: 'allow-todowrite',
+            toolPattern: 'TodoWrite',
+            action: 'allow',
+            description: 'Allow todo tracking',
+        },
+        {
+            id: 'allow-todoread',
+            toolPattern: 'TodoRead',
+            action: 'allow',
+            description: 'Allow todo reading',
+        },
+    ];
+}
+export class ToolApprovalManager {
+    policy;
+    decisions = [];
+    maxDecisions;
+    constructor(policy, maxDecisions) {
+        this.policy = {
+            rules: policy?.rules ?? getDefaultRules(),
+            defaultAction: policy?.defaultAction ?? 'allow',
+            defaultDenyMessage: policy?.defaultDenyMessage ?? 'Tool call denied by approval policy.',
+            enabled: policy?.enabled ?? true,
+        };
+        this.maxDecisions = maxDecisions ?? DEFAULT_MAX_DECISIONS;
+    }
+    evaluate(toolName, input, options) {
+        if (!this.policy.enabled) {
+            return { behavior: 'allow' };
+        }
+        const inputJson = safeJsonStringify(input);
+        const matchedRule = this.findMatchingRule(toolName, inputJson);
+        const action = matchedRule?.action ?? this.policy.defaultAction;
+        const denyMessage = action === 'deny'
+            ? (matchedRule?.denyMessage ??
+                this.policy.defaultDenyMessage ??
+                'Denied by policy.')
+            : undefined;
+        this.recordDecision({
+            timestamp: new Date().toISOString(),
+            toolName,
+            inputPreview: inputJson.slice(0, INPUT_PREVIEW_MAX),
+            title: options?.title,
+            matchedRuleId: matchedRule?.id ?? 'default',
+            action,
+            denyMessage,
+            agentId: options?.agentID,
+        });
+        if (action === 'deny') {
+            return { behavior: 'deny', message: denyMessage };
+        }
+        return { behavior: 'allow' };
+    }
+    getDecisions(limit) {
+        const all = [...this.decisions].reverse();
+        return limit ? all.slice(0, limit) : all;
+    }
+    getDeniedDecisions(limit) {
+        const denied = this.decisions.filter((d) => d.action === 'deny').reverse();
+        return limit ? denied.slice(0, limit) : denied;
+    }
+    clearDecisions() {
+        this.decisions = [];
+    }
+    getPolicy() {
+        return { ...this.policy, rules: [...this.policy.rules] };
+    }
+    setPolicy(policy) {
+        this.policy = { ...policy, rules: [...policy.rules] };
+    }
+    addRule(rule, position) {
+        if (position !== undefined &&
+            position >= 0 &&
+            position < this.policy.rules.length) {
+            this.policy.rules.splice(position, 0, rule);
+        }
+        else {
+            this.policy.rules.push(rule);
+        }
+    }
+    removeRule(ruleId) {
+        const index = this.policy.rules.findIndex((r) => r.id === ruleId);
+        if (index === -1) {
+            return false;
+        }
+        this.policy.rules.splice(index, 1);
+        return true;
+    }
+    setDefaultAction(action) {
+        this.policy.defaultAction = action;
+    }
+    setEnabled(enabled) {
+        this.policy.enabled = enabled;
+    }
+    findMatchingRule(toolName, inputJson) {
+        for (const rule of this.policy.rules) {
+            if (!matchesToolPattern(rule.toolPattern, toolName)) {
+                continue;
+            }
+            if (rule.inputPattern && !inputJson.includes(rule.inputPattern)) {
+                continue;
+            }
+            return rule;
+        }
+        return null;
+    }
+    recordDecision(decision) {
+        this.decisions.push(decision);
+        if (this.decisions.length > this.maxDecisions) {
+            this.decisions = this.decisions.slice(-this.maxDecisions);
+        }
+    }
+}
+function matchesToolPattern(pattern, toolName) {
+    if (pattern === '*') {
+        return true;
+    }
+    if (!pattern.includes('*')) {
+        return pattern === toolName;
+    }
+    const regex = new RegExp('^' +
+        pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*') +
+        '$');
+    return regex.test(toolName);
+}
+function safeJsonStringify(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import type { Plugin } from '@opencode-ai/plugin';
 import { ClaudeManagerPlugin } from './plugin/claude-manager.plugin.js';
-export type { ClaudeCapabilitySnapshot, ClaudeMetadataSnapshot, ClaudeSessionRunResult, ClaudeSessionSummary, ClaudeSessionTranscriptMessage, ManagerPromptRegistry, RunClaudeSessionInput, SessionContextSnapshot, GitDiffResult, GitOperationResult, PersistentRunRecord, PersistentRunResult, ActiveSessionState, ContextWarningLevel, } from './types/contracts.js';
+export type { ClaudeCapabilitySnapshot, ClaudeMetadataSnapshot, ClaudeSessionRunResult, ClaudeSessionSummary, ClaudeSessionTranscriptMessage, ManagerPromptRegistry, RunClaudeSessionInput, SessionContextSnapshot, GitDiffResult, GitOperationResult, PersistentRunRecord, PersistentRunResult, ActiveSessionState, ContextWarningLevel, ToolApprovalRule, ToolApprovalPolicy, ToolApprovalDecision, } from './types/contracts.js';
 export { ClaudeManagerPlugin };
 export declare const plugin: Plugin;

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

@@ -19,6 +19,7 @@ export declare class PersistentManager {
      */
     sendMessage(cwd: string, message: string, options?: {
         model?: string;
+        abortSignal?: AbortSignal;
     }, onEvent?: ClaudeSessionEventHandler): Promise<{
         sessionId: string | undefined;
         finalText: string;

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

@@ -16,6 +16,7 @@ export declare class SessionController {
     sendMessage(cwd: string, message: string, options?: {
         model?: string;
         settingSources?: Array<'user' | 'project' | 'local'>;
+        abortSignal?: AbortSignal;
     }, onEvent?: ClaudeSessionEventHandler): Promise<ClaudeSessionRunResult>;
     /**
      * Send /compact to the current session to compress context.

package/dist/manager/session-controller.js

@@ -30,6 +30,7 @@ export class SessionController {
             includePartialMessages: true,
             model: options?.model,
             settingSources: options?.settingSources ?? ['user', 'project', 'local'],
+            abortSignal: options?.abortSignal,
         };
         if (this.activeSessionId) {
             // Resume existing session

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

@@ -11,6 +11,9 @@ const MANAGER_TOOL_IDS = [
     '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);
@@ -30,16 +33,23 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     toolId === 'claude_manager_send' ||
                         toolId === 'claude_manager_git_commit' ||
                         toolId === 'claude_manager_git_reset' ||
-                        toolId === 'claude_manager_clear'
+                        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: 'accent',
+                color: '#D97757',
                 permission: {
                     '*': 'deny',
+                    read: 'allow',
+                    grep: 'allow',
+                    glob: 'allow',
+                    codesearch: 'allow',
+                    webfetch: 'allow',
+                    websearch: 'allow',
                     ...managerPermissions,
                 },
                 prompt: managerPromptRegistry.managerSystemPrompt,
@@ -106,15 +116,21 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                 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 },
+                        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 }, (event) => {
+                    const result = await services.manager.sendMessage(cwd, args.message, { model: args.model, abortSignal: context.abort }, (event) => {
                         if (event.turns !== undefined) {
                             turnsSoFar = event.turns;
                         }
@@ -124,8 +140,19 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                         const costLabel = `$${costSoFar.toFixed(4)}`;
                         if (event.type === 'tool_call') {
                             let toolName = 'tool';
+                            let inputPreview = '';
                             try {
-                                toolName = JSON.parse(event.text).name ?? 'tool';
+                                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
@@ -135,17 +162,39 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                                 metadata: {
                                     sessionId: event.sessionId,
                                     type: event.type,
-                                    preview: event.text.slice(0, 200),
+                                    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,
-                                    preview: event.text.slice(0, 200),
+                                    thinking: thinkingPreview,
+                                },
+                            });
+                        }
+                        else if (event.type === 'init') {
+                            context.metadata({
+                                title: `Claude Code: Session started`,
+                                metadata: {
+                                    sessionId: event.sessionId,
+                                    prompt: promptPreview,
+                                },
+                            });
+                        }
+                        else if (event.type === 'error') {
+                            context.metadata({
+                                title: `Claude Code: Error`,
+                                metadata: {
+                                    sessionId: event.sessionId,
+                                    error: event.text.slice(0, 200),
                                 },
                             });
                         }
@@ -299,6 +348,94 @@ export const ClaudeManagerPlugin = async ({ 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);
+                },
+            }),
         },
     };
 };

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

@@ -1,8 +1,10 @@
 import { ClaudeSessionService } from '../claude/claude-session.service.js';
+import { ToolApprovalManager } from '../claude/tool-approval-manager.js';
 import { PersistentManager } from '../manager/persistent-manager.js';
 interface ClaudeManagerPluginServices {
     manager: PersistentManager;
     sessions: ClaudeSessionService;
+    approvalManager: ToolApprovalManager;
 }
 export declare function getOrCreatePluginServices(worktree: string): ClaudeManagerPluginServices;
 export {};

package/dist/plugin/service-factory.js

@@ -1,5 +1,6 @@
 import { ClaudeAgentSdkAdapter } from '../claude/claude-agent-sdk-adapter.js';
 import { ClaudeSessionService } from '../claude/claude-session.service.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';
@@ -15,7 +16,8 @@ export function getOrCreatePluginServices(worktree) {
     if (cachedServices) {
         return cachedServices;
     }
-    const sdkAdapter = new ClaudeAgentSdkAdapter();
+    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();
@@ -29,6 +31,7 @@ export function getOrCreatePluginServices(worktree) {
     const services = {
         manager,
         sessions: sessionService,
+        approvalManager,
     };
     serviceCache.set(worktree, services);
     return services;

package/dist/types/contracts.d.ts

@@ -67,6 +67,7 @@ export interface RunClaudeSessionInput {
     includePartialMessages?: boolean;
     settingSources?: ClaudeSettingSource[];
     maxTurns?: number;
+    abortSignal?: AbortSignal;
 }
 export interface ClaudeSessionRunResult {
     sessionId?: string;
@@ -166,3 +167,29 @@ export interface PersistentRunRecord {
 export interface PersistentRunResult {
     run: PersistentRunRecord;
 }
+export interface ToolApprovalRule {
+    id: string;
+    description?: string;
+    /** Tool name — exact match or glob with * wildcard */
+    toolPattern: string;
+    /** Optional substring match against JSON-serialized tool input */
+    inputPattern?: string;
+    action: 'allow' | 'deny';
+    denyMessage?: string;
+}
+export interface ToolApprovalPolicy {
+    rules: ToolApprovalRule[];
+    defaultAction: 'allow' | 'deny';
+    defaultDenyMessage?: string;
+    enabled: boolean;
+}
+export interface ToolApprovalDecision {
+    timestamp: string;
+    toolName: string;
+    inputPreview: string;
+    title?: string;
+    matchedRuleId: string;
+    action: 'allow' | 'deny';
+    denyMessage?: string;
+    agentId?: string;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doingdev/opencode-claude-manager-plugin",
-  "version": "0.1.12",
+  "version": "0.1.15",
   "description": "OpenCode plugin that orchestrates Claude Code sessions.",
   "keywords": [
     "opencode",