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

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

@@ -1,7 +1,8 @@
 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>;
-export interface ClaudeAgentSdkFacade {
+interface ClaudeAgentSdkFacade {
     query(params: {
         prompt: string;
         options?: Options;
@@ -15,10 +16,12 @@ export 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[]>;
     probeCapabilities(cwd: string, settingSources?: SettingSource[]): Promise<ClaudeCapabilitySnapshot>;
     private buildOptions;
 }
+export {};

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

@@ -1,22 +1,25 @@
-import type { ClaudeSessionRunResult, PersistentRunRecord, PersistentRunResult, SessionContextSnapshot, GitDiffResult, GitOperationResult } from '../types/contracts.js';
+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';
-export type PersistentManagerProgressHandler = (run: PersistentRunRecord) => void | Promise<void>;
+type PersistentManagerProgressHandler = (run: PersistentRunRecord) => void | Promise<void>;
 export declare class PersistentManager {
     private readonly sessionController;
     private readonly gitOps;
     private readonly stateStore;
     private readonly contextTracker;
-    constructor(sessionController: SessionController, gitOps: GitOperations, stateStore: FileRunStateStore, contextTracker: 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;
+        abortSignal?: AbortSignal;
     }, onEvent?: ClaudeSessionEventHandler): Promise<{
         sessionId: string | undefined;
         finalText: string;
@@ -48,6 +51,10 @@ export declare class PersistentManager {
      * 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.
@@ -62,3 +69,4 @@ export declare class PersistentManager {
     listRuns(cwd: string): Promise<PersistentRunRecord[]>;
     getRun(cwd: string, runId: string): Promise<PersistentRunRecord | null>;
 }
+export {};

package/dist/manager/persistent-manager.js

@@ -4,11 +4,13 @@ export class PersistentManager {
     gitOps;
     stateStore;
     contextTracker;
-    constructor(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.
@@ -16,6 +18,9 @@ export class PersistentManager {
      */
     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,
@@ -58,7 +63,17 @@ export class PersistentManager {
      * Compact the current session to free context.
      */
     async compactSession(cwd, onEvent) {
-        return this.sessionController.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.

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

@@ -1,5 +1,5 @@
-import type { ClaudeSessionRunResult, SessionContextSnapshot } from '../types/contracts.js';
 import type { ClaudeAgentSdkAdapter, ClaudeSessionEventHandler } from '../claude/claude-agent-sdk-adapter.js';
+import type { ClaudeSessionRunResult, SessionContextSnapshot } from '../types/contracts.js';
 import type { ContextTracker } from './context-tracker.js';
 export declare class SessionController {
     private readonly sdkAdapter;
@@ -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

@@ -1,5 +1,5 @@
-import { readFile, writeFile, mkdir } from 'node:fs/promises';
-import { join, dirname } from 'node:path';
+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;
@@ -29,7 +29,8 @@ export class SessionController {
             permissionMode: 'acceptEdits',
             includePartialMessages: true,
             model: options?.model,
-            settingSources: options?.settingSources ?? ['project', 'local'],
+            settingSources: options?.settingSources ?? ['user', 'project', 'local'],
+            abortSignal: options?.abortSignal,
         };
         if (this.activeSessionId) {
             // Resume existing session

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

@@ -1,4 +1,2 @@
 import { type Plugin } from '@opencode-ai/plugin';
-import type { PersistentRunRecord } from '../types/contracts.js';
 export declare const ClaudeManagerPlugin: Plugin;
-export declare function formatRunToolResult(run: PersistentRunRecord): string;

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,
@@ -104,27 +114,113 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     cwd: tool.schema.string().optional(),
                 },
                 async execute(args, context) {
-                    annotateToolRun(context, 'Sending to Claude Code session', {
-                        hasActiveSession: services.manager.getStatus().sessionId !== null,
+                    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,
+                        },
                     });
-                    const result = await services.manager.sendMessage(args.cwd ?? context.worktree, args.message, { model: args.model }, (event) => {
-                        if (event.type === 'assistant' || event.type === 'tool_call') {
+                    let turnsSoFar = 0;
+                    let costSoFar = 0;
+                    const result = await services.manager.sendMessage(cwd, args.message, { model: args.model, 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 working...',
+                                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),
                                 },
                             });
                         }
                     });
+                    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 },
+                        });
+                    }
                     return JSON.stringify({
                         sessionId: result.sessionId,
                         finalText: result.finalText,
                         turns: result.turns,
                         totalCostUsd: result.totalCostUsd,
                         context: result.context,
-                        contextWarning: formatContextWarning(result.context),
+                        contextWarning,
                     }, null, 2);
                 },
             }),
@@ -189,6 +285,9 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     const status = services.manager.getStatus();
                     return JSON.stringify({
                         ...status,
+                        transcriptFile: status.sessionId
+                            ? `.claude-manager/transcripts/${status.sessionId}.json`
+                            : null,
                         contextWarning: formatContextWarning(status),
                     }, null, 2);
                 },
@@ -210,18 +309,26 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                 },
             }),
             claude_manager_sessions: tool({
-                description: 'List Claude sessions or inspect a saved transcript.',
+                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 transcript = await services.sessions.getTranscript(args.sessionId, args.cwd ?? context.worktree);
-                        return JSON.stringify(transcript, null, 2);
+                        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(args.cwd ?? context.worktree);
+                    const sessions = await services.sessions.listSessions(cwd);
                     return JSON.stringify(sessions, null, 2);
                 },
             }),
@@ -241,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);
+                },
+            }),
         },
     };
 };
@@ -304,16 +499,3 @@ function formatContextWarning(context) {
         .replace('{turns}', String(totalTurns))
         .replace('{cost}', totalCostUsd.toFixed(2));
 }
-export function formatRunToolResult(run) {
-    return JSON.stringify({
-        runId: run.id,
-        status: run.status,
-        task: run.task,
-        sessionId: run.sessionId,
-        finalSummary: run.finalSummary,
-        messageCount: run.messages.length,
-        actionCount: run.actions.length,
-        commits: run.commits,
-        context: run.context,
-    }, null, 2);
-}

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

@@ -1,7 +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';
-export interface ClaudeManagerPluginServices {
+interface ClaudeManagerPluginServices {
     manager: PersistentManager;
     sessions: ClaudeSessionService;
+    approvalManager: ToolApprovalManager;
 }
 export declare function getOrCreatePluginServices(worktree: string): ClaudeManagerPluginServices;
+export {};

package/dist/plugin/service-factory.js

@@ -1,8 +1,10 @@
 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';
+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';
@@ -14,19 +16,22 @@ 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();
     const sessionController = new SessionController(sdkAdapter, contextTracker, managerPromptRegistry.claudeCodeSessionPrompt);
     const gitOps = new GitOperations(worktree);
     const stateStore = new FileRunStateStore();
-    const manager = new PersistentManager(sessionController, gitOps, stateStore, contextTracker);
+    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 services = {
         manager,
         sessions: sessionService,
+        approvalManager,
     };
     serviceCache.set(worktree, services);
     return services;

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

@@ -1,6 +1,6 @@
-import { randomUUID } from 'node:crypto';
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
+import { isFileNotFoundError, writeJsonAtomically, } from '../util/fs-helpers.js';
 export class FileRunStateStore {
     baseDirectoryName;
     writeQueues = new Map();
@@ -85,13 +85,3 @@ export class FileRunStateStore {
         }
     }
 }
-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/state/transcript-store.d.ts

@@ -0,0 +1,15 @@
+import type { ClaudeSessionEvent } from '../types/contracts.js';
+export declare class TranscriptStore {
+    private readonly baseDirectoryName;
+    constructor(baseDirectoryName?: string);
+    /**
+     * Append new events to the transcript file for the given session.
+     * Creates the file if it does not exist. Strips trailing partials before persisting.
+     */
+    appendEvents(cwd: string, sessionId: string, newEvents: ClaudeSessionEvent[]): Promise<void>;
+    /**
+     * Read all persisted transcript events for a session.
+     */
+    readEvents(cwd: string, sessionId: string): Promise<ClaudeSessionEvent[]>;
+    private getTranscriptPath;
+}

package/dist/state/transcript-store.js

@@ -0,0 +1,44 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { appendTranscriptEvents, stripTrailingPartials, } from '../util/transcript-append.js';
+import { isFileNotFoundError, writeJsonAtomically, } from '../util/fs-helpers.js';
+export class TranscriptStore {
+    baseDirectoryName;
+    constructor(baseDirectoryName = '.claude-manager') {
+        this.baseDirectoryName = baseDirectoryName;
+    }
+    /**
+     * Append new events to the transcript file for the given session.
+     * Creates the file if it does not exist. Strips trailing partials before persisting.
+     */
+    async appendEvents(cwd, sessionId, newEvents) {
+        if (newEvents.length === 0) {
+            return;
+        }
+        const filePath = this.getTranscriptPath(cwd, sessionId);
+        const existing = await this.readEvents(cwd, sessionId);
+        const merged = appendTranscriptEvents(existing, newEvents);
+        const cleaned = stripTrailingPartials(merged);
+        await fs.mkdir(path.dirname(filePath), { recursive: true });
+        await writeJsonAtomically(filePath, cleaned);
+    }
+    /**
+     * Read all persisted transcript events for a session.
+     */
+    async readEvents(cwd, sessionId) {
+        const filePath = this.getTranscriptPath(cwd, sessionId);
+        try {
+            const content = await fs.readFile(filePath, 'utf8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            if (isFileNotFoundError(error)) {
+                return [];
+            }
+            throw error;
+        }
+    }
+    getTranscriptPath(cwd, sessionId) {
+        return path.join(cwd, this.baseDirectoryName, 'transcripts', `${sessionId}.json`);
+    }
+}

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/dist/util/fs-helpers.d.ts

@@ -0,0 +1,2 @@
+export declare function writeJsonAtomically(filePath: string, data: unknown): Promise<void>;
+export declare function isFileNotFoundError(error: unknown): error is NodeJS.ErrnoException;

package/dist/util/fs-helpers.js

@@ -0,0 +1,12 @@
+import { randomUUID } from 'node:crypto';
+import { promises as fs } from 'node:fs';
+export 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);
+}
+export function isFileNotFoundError(error) {
+    return (error instanceof Error &&
+        'code' in error &&
+        error.code === 'ENOENT');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doingdev/opencode-claude-manager-plugin",
-  "version": "0.1.11",
+  "version": "0.1.15",
   "description": "OpenCode plugin that orchestrates Claude Code sessions.",
   "keywords": [
     "opencode",
@@ -40,6 +40,7 @@
     "@vitest/coverage-v8": "^4.1.0",
     "eslint": "^9.22.0",
     "globals": "^15.15.0",
+    "knip": "^6.0.2",
     "prettier": "^3.8.1",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.57.1",
@@ -51,6 +52,7 @@
     "lint": "eslint .",
     "format": "prettier --write .",
     "test": "vitest run",
+    "knip": "knip",
     "release": "pnpm run build && pnpm version patch && pnpm publish"
   }
 }