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

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 {
@@ -133,6 +151,7 @@ export class ClaudeAgentSdkAdapter {
             settingSources: input.settingSources,
             maxTurns: input.maxTurns,
             model: input.model,
+            effort: input.effort,
             permissionMode: input.permissionMode ?? 'acceptEdits',
             systemPrompt: input.systemPrompt
                 ? { type: 'preset', preset: 'claude_code', append: input.systemPrompt }
@@ -145,6 +164,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/session-live-tailer.d.ts

@@ -0,0 +1,51 @@
+import type { LiveTailEvent, ToolOutputPreview } from '../types/contracts.js';
+/**
+ * Tails Claude Code session JSONL files for live tool output.
+ *
+ * The SDK streams high-level events (assistant text, tool_call summaries, results)
+ * but does not expose the raw tool output that Claude Code writes to the JSONL
+ * transcript on disk.  This service fills that gap by polling the file for new
+ * lines, parsing each one, and forwarding parsed events to a caller-supplied
+ * callback.
+ */
+export declare class SessionLiveTailer {
+    private activeTails;
+    /**
+     * Locate the JSONL file for a session.
+     *
+     * Claude Code stores transcripts at:
+     *   ~/.claude/projects/<sanitized-cwd>/sessions/<session-id>.jsonl
+     *
+     * The `<sanitized-cwd>` folder name is an internal implementation detail that
+     * can change across Claude Code versions, so we search all project directories
+     * for the session file rather than attempting to replicate the sanitisation.
+     */
+    findSessionFile(sessionId: string, cwd?: string): string | null;
+    /**
+     * Check whether we can locate a JSONL file for the given session.
+     */
+    sessionFileExists(sessionId: string, cwd?: string): boolean;
+    /**
+     * Poll a session's JSONL file for new lines and emit parsed events.
+     *
+     * Returns a stop function.  The caller **must** invoke it when tailing is no
+     * longer needed (e.g. when the session completes or the tool is interrupted).
+     */
+    startTailing(sessionId: string, cwd: string | undefined, onEvent: (event: LiveTailEvent) => void, pollIntervalMs?: number): () => void;
+    /**
+     * Stop tailing a specific session.
+     */
+    stopTailing(sessionId: string): void;
+    /**
+     * Stop all active tails (cleanup on shutdown).
+     */
+    stopAll(): void;
+    /**
+     * Read the last N lines from a session JSONL file.
+     */
+    getLastLines(sessionId: string, cwd: string | undefined, lineCount?: number): Promise<string[]>;
+    /**
+     * Extract a preview of recent tool output from the tail of a session file.
+     */
+    getToolOutputPreview(sessionId: string, cwd: string | undefined, maxEntries?: number): Promise<ToolOutputPreview[]>;
+}

package/dist/claude/session-live-tailer.js

@@ -0,0 +1,269 @@
+import { createReadStream, existsSync, readdirSync, statSync } from 'node:fs';
+import { createInterface } from 'node:readline';
+import path from 'node:path';
+import os from 'node:os';
+/**
+ * Tails Claude Code session JSONL files for live tool output.
+ *
+ * The SDK streams high-level events (assistant text, tool_call summaries, results)
+ * but does not expose the raw tool output that Claude Code writes to the JSONL
+ * transcript on disk.  This service fills that gap by polling the file for new
+ * lines, parsing each one, and forwarding parsed events to a caller-supplied
+ * callback.
+ */
+export class SessionLiveTailer {
+    activeTails = new Map();
+    // ── Path discovery ──────────────────────────────────────────────────
+    /**
+     * Locate the JSONL file for a session.
+     *
+     * Claude Code stores transcripts at:
+     *   ~/.claude/projects/<sanitized-cwd>/sessions/<session-id>.jsonl
+     *
+     * The `<sanitized-cwd>` folder name is an internal implementation detail that
+     * can change across Claude Code versions, so we search all project directories
+     * for the session file rather than attempting to replicate the sanitisation.
+     */
+    findSessionFile(sessionId, cwd) {
+        const projectsDir = path.join(os.homedir(), '.claude', 'projects');
+        if (!existsSync(projectsDir)) {
+            return null;
+        }
+        // If cwd is provided, try the sanitised form first (best-effort fast path).
+        if (cwd) {
+            const sanitised = cwd.replace(/\//g, '-');
+            const candidate = path.join(projectsDir, sanitised, 'sessions', `${sessionId}.jsonl`);
+            if (existsSync(candidate)) {
+                return candidate;
+            }
+        }
+        // Fall back to scanning all project directories.
+        try {
+            for (const entry of readdirSync(projectsDir, { withFileTypes: true })) {
+                if (!entry.isDirectory())
+                    continue;
+                const candidate = path.join(projectsDir, entry.name, 'sessions', `${sessionId}.jsonl`);
+                if (existsSync(candidate)) {
+                    return candidate;
+                }
+            }
+        }
+        catch {
+            // Permission denied or similar — nothing we can do.
+        }
+        return null;
+    }
+    /**
+     * Check whether we can locate a JSONL file for the given session.
+     */
+    sessionFileExists(sessionId, cwd) {
+        return this.findSessionFile(sessionId, cwd) !== null;
+    }
+    // ── Live tailing ────────────────────────────────────────────────────
+    /**
+     * Poll a session's JSONL file for new lines and emit parsed events.
+     *
+     * Returns a stop function.  The caller **must** invoke it when tailing is no
+     * longer needed (e.g. when the session completes or the tool is interrupted).
+     */
+    startTailing(sessionId, cwd, onEvent, pollIntervalMs = 150) {
+        const filePath = this.findSessionFile(sessionId, cwd);
+        if (!filePath) {
+            onEvent({
+                type: 'error',
+                sessionId,
+                error: `Session JSONL not found for ${sessionId}`,
+            });
+            return () => { };
+        }
+        let offset = statSync(filePath).size;
+        let buffer = '';
+        let reading = false; // guard against overlapping reads
+        const interval = setInterval(() => {
+            if (reading)
+                return;
+            try {
+                const currentSize = statSync(filePath).size;
+                if (currentSize < offset) {
+                    // File was truncated (rotation / compaction) — reset.
+                    offset = 0;
+                    buffer = '';
+                }
+                if (currentSize <= offset)
+                    return;
+                reading = true;
+                const stream = createReadStream(filePath, {
+                    start: offset,
+                    end: currentSize - 1,
+                    encoding: 'utf8',
+                });
+                let chunk = '';
+                stream.on('data', (data) => {
+                    chunk += data;
+                });
+                stream.on('end', () => {
+                    reading = false;
+                    offset = currentSize;
+                    buffer += chunk;
+                    const lines = buffer.split('\n');
+                    // Keep the last (possibly incomplete) segment in the buffer.
+                    buffer = lines.pop() ?? '';
+                    for (const line of lines) {
+                        const trimmed = line.trim();
+                        if (!trimmed)
+                            continue;
+                        try {
+                            const parsed = JSON.parse(trimmed);
+                            onEvent({
+                                type: 'line',
+                                sessionId,
+                                data: parsed,
+                                rawLine: trimmed,
+                            });
+                        }
+                        catch {
+                            onEvent({
+                                type: 'line',
+                                sessionId,
+                                data: null,
+                                rawLine: trimmed,
+                            });
+                        }
+                    }
+                });
+                stream.on('error', (err) => {
+                    reading = false;
+                    onEvent({
+                        type: 'error',
+                        sessionId,
+                        error: err.message,
+                    });
+                });
+            }
+            catch (err) {
+                reading = false;
+                onEvent({
+                    type: 'error',
+                    sessionId,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }, pollIntervalMs);
+        this.activeTails.set(sessionId, interval);
+        return () => this.stopTailing(sessionId);
+    }
+    /**
+     * Stop tailing a specific session.
+     */
+    stopTailing(sessionId) {
+        const interval = this.activeTails.get(sessionId);
+        if (interval) {
+            clearInterval(interval);
+            this.activeTails.delete(sessionId);
+        }
+    }
+    /**
+     * Stop all active tails (cleanup on shutdown).
+     */
+    stopAll() {
+        for (const [, interval] of this.activeTails) {
+            clearInterval(interval);
+        }
+        this.activeTails.clear();
+    }
+    // ── Snapshot helpers ────────────────────────────────────────────────
+    /**
+     * Read the last N lines from a session JSONL file.
+     */
+    async getLastLines(sessionId, cwd, lineCount = 20) {
+        const filePath = this.findSessionFile(sessionId, cwd);
+        if (!filePath)
+            return [];
+        const lines = [];
+        const rl = createInterface({
+            input: createReadStream(filePath, { encoding: 'utf8' }),
+        });
+        for await (const line of rl) {
+            lines.push(line);
+            if (lines.length > lineCount) {
+                lines.shift();
+            }
+        }
+        return lines;
+    }
+    /**
+     * Extract a preview of recent tool output from the tail of a session file.
+     */
+    async getToolOutputPreview(sessionId, cwd, maxEntries = 5) {
+        const lastLines = await this.getLastLines(sessionId, cwd, 100);
+        const previews = [];
+        for (const line of lastLines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                const parsed = JSON.parse(trimmed);
+                const preview = extractToolOutput(parsed);
+                if (preview) {
+                    previews.push(preview);
+                }
+            }
+            catch {
+                // skip unparseable lines
+            }
+        }
+        return previews.slice(-maxEntries);
+    }
+}
+// ── Internal helpers ────────────────────────────────────────────────────
+/**
+ * Attempt to extract tool output information from a JSONL record.
+ *
+ * Claude Code JSONL records with tool results can appear as:
+ *   1. A top-level `{ type: "user", message: { content: [{ type: "tool_result", ... }] } }`
+ *   2. Direct `tool_result` entries (less common).
+ */
+function extractToolOutput(record) {
+    // Pattern 1: user message wrapping tool_result content blocks
+    if (record.type === 'user') {
+        const message = record.message;
+        if (!message)
+            return null;
+        const content = message.content;
+        if (!Array.isArray(content))
+            return null;
+        for (const block of content) {
+            if (block &&
+                typeof block === 'object' &&
+                block.type === 'tool_result') {
+                const b = block;
+                return {
+                    toolUseId: typeof b.tool_use_id === 'string' ? b.tool_use_id : '',
+                    content: stringifyContent(b.content),
+                    isError: b.is_error === true,
+                };
+            }
+        }
+    }
+    // Pattern 2: direct tool_result record (varies by Claude Code version)
+    if (record.type === 'tool_result') {
+        return {
+            toolUseId: typeof record.tool_use_id === 'string' ? record.tool_use_id : '',
+            content: stringifyContent(record.content),
+            isError: record.is_error === true,
+        };
+    }
+    return null;
+}
+function stringifyContent(value) {
+    if (typeof value === 'string')
+        return value;
+    if (value === undefined || value === null)
+        return '';
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}

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,6 @@
 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, LiveTailEvent, ToolOutputPreview, ToolApprovalRule, ToolApprovalPolicy, ToolApprovalDecision, } from './types/contracts.js';
+export { SessionLiveTailer } from './claude/session-live-tailer.js';
 export { ClaudeManagerPlugin };
 export declare const plugin: Plugin;

package/dist/index.js

@@ -1,3 +1,4 @@
 import { ClaudeManagerPlugin } from './plugin/claude-manager.plugin.js';
+export { SessionLiveTailer } from './claude/session-live-tailer.js';
 export { ClaudeManagerPlugin };
 export const plugin = ClaudeManagerPlugin;

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

@@ -15,7 +15,9 @@ export declare class SessionController {
      */
     sendMessage(cwd: string, message: string, options?: {
         model?: string;
+        effort?: 'low' | 'medium' | 'high' | 'max';
         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

@@ -29,15 +29,19 @@ export class SessionController {
             permissionMode: '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
+            // 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

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),
                                 },
                             });
                         }
@@ -165,6 +214,16 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                             metadata: { sessionId: result.sessionId },
                         });
                     }
+                    // Fetch recent tool output from the JSONL file for richer feedback.
+                    let toolOutputs = [];
+                    if (result.sessionId) {
+                        try {
+                            toolOutputs = await services.liveTailer.getToolOutputPreview(result.sessionId, cwd, 3);
+                        }
+                        catch {
+                            // Non-critical — the JSONL file may not exist yet.
+                        }
+                    }
                     return JSON.stringify({
                         sessionId: result.sessionId,
                         finalText: result.finalText,
@@ -172,6 +231,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                         totalCostUsd: result.totalCostUsd,
                         context: result.context,
                         contextWarning,
+                        toolOutputs: toolOutputs.length > 0 ? toolOutputs : undefined,
                     }, null, 2);
                 },
             }),
@@ -299,6 +359,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,12 @@
 import { ClaudeSessionService } from '../claude/claude-session.service.js';
+import { SessionLiveTailer } from '../claude/session-live-tailer.js';
+import { ToolApprovalManager } from '../claude/tool-approval-manager.js';
 import { PersistentManager } from '../manager/persistent-manager.js';
 interface ClaudeManagerPluginServices {
     manager: PersistentManager;
     sessions: ClaudeSessionService;
+    approvalManager: ToolApprovalManager;
+    liveTailer: SessionLiveTailer;
 }
 export declare function getOrCreatePluginServices(worktree: string): ClaudeManagerPluginServices;
 export {};

package/dist/plugin/service-factory.js

@@ -1,5 +1,7 @@
 import { ClaudeAgentSdkAdapter } from '../claude/claude-agent-sdk-adapter.js';
 import { ClaudeSessionService } from '../claude/claude-session.service.js';
+import { SessionLiveTailer } from '../claude/session-live-tailer.js';
+import { ToolApprovalManager } from '../claude/tool-approval-manager.js';
 import { ClaudeMetadataService } from '../metadata/claude-metadata.service.js';
 import { RepoClaudeConfigReader } from '../metadata/repo-claude-config-reader.js';
 import { FileRunStateStore } from '../state/file-run-state-store.js';
@@ -15,7 +17,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();
@@ -26,9 +29,12 @@ export function getOrCreatePluginServices(worktree) {
     const manager = new PersistentManager(sessionController, gitOps, stateStore, contextTracker, transcriptStore);
     // Try to restore active session state (fire and forget)
     manager.tryRestore(worktree).catch(() => { });
+    const liveTailer = new SessionLiveTailer();
     const services = {
         manager,
         sessions: sessionService,
+        approvalManager,
+        liveTailer,
     };
     serviceCache.set(worktree, services);
     return services;

package/dist/prompts/registry.js

@@ -1,41 +1,122 @@
 export const managerPromptRegistry = {
     managerSystemPrompt: [
-        'You orchestrate Claude Code through a persistent session. You are a user proxy —',
-        'your job is to make Claude Code do the work, not to do it yourself.',
+        'You are a senior IC operating Claude Code through a persistent session.',
+        'Your job is to make Claude Code do the work — not to write code yourself.',
+        'Think like a staff engineer: correctness, maintainability, tests, rollback safety,',
+        'and clear communication to the user.',
         '',
-        '## Workflow',
-        '1. claude_manager_send — send clear, specific instructions',
-        '2. claude_manager_git_diff — review what changed',
-        '3. claude_manager_git_commit — checkpoint good work',
-        '4. claude_manager_git_reset — discard bad work',
-        '5. claude_manager_clear — fresh session when needed',
+        '## Decision loop',
+        'On every turn, choose exactly one action:',
+        '  investigate — read files, grep, search the codebase to build context',
+        '  delegate   — send a focused instruction to Claude Code via claude_manager_send',
+        '  review     — run claude_manager_git_diff to inspect what changed',
+        '  validate   — tell Claude Code to run tests, lint, or typecheck',
+        '  commit     — checkpoint good work with claude_manager_git_commit',
+        '  correct    — send a targeted fix instruction (never "try again")',
+        '  reset      — discard bad work with claude_manager_git_reset',
+        '  ask        — ask the user one narrow, high-value question',
+        '',
+        'Default order: investigate → delegate → review → validate → commit.',
+        'Skip steps only when you have strong evidence they are unnecessary.',
+        '',
+        '## Before you delegate',
+        '1. Read the relevant files yourself (you have read, grep, glob).',
+        '   For broad investigations, scope them narrowly or use subagents to avoid',
+        '   polluting your own context with excessive file contents.',
+        '2. Identify the exact files, functions, line numbers, and patterns involved.',
+        '3. Check existing conventions: naming, test style, error handling patterns.',
+        '4. Craft an instruction that a senior engineer would find unambiguous.',
+        '   Bad:  "Fix the auth bug"',
+        '   Good: "In src/auth/session.ts, the `validateToken` function (line 42)',
+        '          throws on expired tokens instead of returning null. Change it to',
+        '          return null and update the caller in src/routes/login.ts:87."',
+        '',
+        '## After delegation — mandatory review',
+        'Never claim success without evidence:',
+        '1. claude_manager_git_diff — read the actual diff, not just the summary.',
+        '2. Verify the diff matches what you asked for. Check for:',
+        '   - Unintended changes or regressions',
+        '   - Missing test updates',
+        '   - Style violations against repo conventions',
+        '3. If changes look correct, tell Claude Code to run tests/lint/typecheck.',
+        '4. Only commit after verification passes.',
+        '5. If the diff is wrong: send a specific correction or reset.',
+        '',
+        '## Handling ambiguity',
+        'When requirements are unclear:',
+        '1. First, try to resolve it yourself — read code, check tests, grep for usage.',
+        '2. If ambiguity remains, ask the user ONE specific question.',
+        '   Bad:  "What should I do?"',
+        '   Good: "The `UserService` has both `deactivate()` and `softDelete()` —',
+        '          should the new endpoint use deactivation (reversible) or',
+        '          soft-delete (audit-logged)?"',
+        '3. Never block on multiple questions at once.',
+        '',
+        '## Correction and recovery',
+        'If Claude Code produces wrong output:',
+        '1. First correction: send a specific, targeted fix instruction.',
+        '2. Second correction on the same issue: reset, clear the session,',
+        '   and rewrite the prompt incorporating lessons from both failures.',
+        'Never send three corrections for the same problem in one session.',
+        '',
+        '## Multi-step tasks',
+        '- Decompose large tasks into sequential focused instructions.',
+        '- Commit after each successful step (checkpoint for rollback).',
+        '- Tell Claude Code to use subagents for independent parallel work.',
+        '- For complex design decisions, tell Claude Code to "think hard".',
+        '- Prefer small diffs — they are easier to review and safer to ship.',
         '',
         '## Context management',
-        'Check the context snapshot in each send result:',
-        '- Under 50%: proceed freely',
-        '- 50-70%: consider if next task should reuse or start fresh',
-        '- Over 70%: compact or clear before heavy work',
-        '- Over 85% or 200k tokens: clear immediately',
-        '',
-        '## Delegation principles',
-        '- Write specific task descriptions with file paths, function names, error messages',
-        '- For large features, send sequential focused instructions',
-        '- Tell Claude Code to use subagents for parallel/independent parts',
-        '- After implementation, always review with git diff before committing',
-        '- If work is wrong, send a correction (specific, not "try again") or reset',
+        'Check the context snapshot returned by each send:',
+        '- Under 50%: proceed freely.',
+        '- 50–70%: finish current step, then evaluate if a fresh session is needed.',
+        '- Over 70%: compact or clear before sending heavy instructions.',
+        '- Over 85%: clear the session immediately.',
+        '',
+        '## Tools reference',
+        'claude_manager_send     — send instruction (creates or resumes session)',
+        'claude_manager_git_diff — review all uncommitted changes',
+        'claude_manager_git_commit — stage all + commit',
+        'claude_manager_git_reset  — hard reset + clean (destructive)',
+        'claude_manager_clear    — drop session, next send starts fresh',
+        'claude_manager_status   — context health snapshot',
+        'claude_manager_metadata — inspect repo Claude config',
+        'claude_manager_sessions — list sessions or read transcripts',
+        'claude_manager_runs     — list or inspect run records',
+        '',
+        '## Autonomy blockers — surface these to the user',
+        'Be candid about what you cannot do autonomously:',
+        '- Credentials, API keys, or secrets you do not have.',
+        '- Architectural decisions with trade-offs the user should weigh.',
+        '- Destructive actions on shared state (deploy, publish, force-push).',
+        '- Access to external services or environments you cannot reach.',
+        'State the blocker, what you need, and a concrete suggestion to unblock.',
     ].join('\n'),
     claudeCodeSessionPrompt: [
-        'You are being directed by an expert automated operator. Treat each message',
-        'as a precise instruction from a skilled Claude Code user.',
-        '',
-        'Key behaviors:',
-        '- Execute instructions directly without asking for clarification',
-        '- Use the Agent tool to spawn subagents for parallel/independent work',
-        '- Be concise — no preamble, no restating the task',
-        '- Do NOT run git commit, git push, or git reset — the operator handles git',
-        '- After completing work, end with a brief verification summary',
-        '- When context is heavy, prefer targeted file reads over reading entire files',
-        '- Report blockers immediately and specifically',
+        'You are directed by an expert automated operator.',
+        'Treat each message as a precise instruction from a senior engineer.',
+        '',
+        '## Execution rules',
+        '- Execute instructions directly. Do not ask for clarification.',
+        '- Be concise — no preamble, no restating the task.',
+        '- Prefer targeted file reads over reading entire files.',
+        '- Use the Agent tool for independent parallel work.',
+        '',
+        '## Quality expectations',
+        '- Follow existing repo conventions (naming, style, patterns).',
+        '- When creating or modifying code, consider edge cases and error handling.',
+        '- When modifying existing code, preserve surrounding style and structure.',
+        '- If asked to implement a feature, include relevant tests unless told otherwise.',
+        '- Run tests/lint/typecheck when instructed; report exact output on failure.',
+        '',
+        '## Git boundary — do NOT run these commands:',
+        'git commit, git push, git reset, git checkout, git stash.',
+        'The operator manages all git operations externally.',
+        '',
+        '## Reporting',
+        '- End with a brief verification summary: what was done, what was verified.',
+        '- Report blockers immediately with specifics: file, line, error message.',
+        '- If a task is partially complete, state exactly what remains.',
     ].join('\n'),
     contextWarnings: {
         moderate: 'Session context is filling up ({percent}% estimated). Consider whether a fresh session would be more efficient.',

package/dist/types/contracts.d.ts

@@ -57,6 +57,7 @@ export interface RunClaudeSessionInput {
     prompt: string;
     systemPrompt?: string;
     model?: string;
+    effort?: 'low' | 'medium' | 'high' | 'max';
     permissionMode?: 'default' | 'acceptEdits' | 'plan' | 'dontAsk';
     allowedTools?: string[];
     disallowedTools?: string[];
@@ -67,6 +68,7 @@ export interface RunClaudeSessionInput {
     includePartialMessages?: boolean;
     settingSources?: ClaudeSettingSource[];
     maxTurns?: number;
+    abortSignal?: AbortSignal;
 }
 export interface ClaudeSessionRunResult {
     sessionId?: string;
@@ -166,3 +168,41 @@ export interface PersistentRunRecord {
 export interface PersistentRunResult {
     run: PersistentRunRecord;
 }
+export interface LiveTailEvent {
+    type: 'line' | 'error' | 'end';
+    sessionId: string;
+    data?: unknown;
+    rawLine?: string;
+    error?: string;
+}
+export interface ToolOutputPreview {
+    toolUseId: string;
+    content: string;
+    isError: boolean;
+}
+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.16",
   "description": "OpenCode plugin that orchestrates Claude Code sessions.",
   "keywords": [
     "opencode",