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

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

@@ -151,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 }
@@ -244,6 +245,36 @@ function normalizeSdkMessages(message, includePartials) {
     if (message.type === 'user') {
         return normalizeUserSdkMessage(message, sessionId);
     }
+    if (message.type === 'tool_progress') {
+        const toolName = 'tool_name' in message && typeof message.tool_name === 'string'
+            ? message.tool_name
+            : 'tool';
+        const elapsed = 'elapsed_time_seconds' in message &&
+            typeof message.elapsed_time_seconds === 'number'
+            ? message.elapsed_time_seconds
+            : 0;
+        return [
+            {
+                type: 'tool_progress',
+                sessionId,
+                text: JSON.stringify({ name: toolName, elapsed }),
+                rawType: message.type,
+            },
+        ];
+    }
+    if (message.type === 'tool_use_summary') {
+        const summary = 'summary' in message && typeof message.summary === 'string'
+            ? message.summary
+            : '';
+        return [
+            {
+                type: 'tool_summary',
+                sessionId,
+                text: summary,
+                rawType: message.type,
+            },
+        ];
+    }
     return [
         {
             type: 'system',

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/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, ToolApprovalRule, ToolApprovalPolicy, ToolApprovalDecision, } from './types/contracts.js';
+export type { ClaudeCapabilitySnapshot, ClaudeMetadataSnapshot, ClaudeSessionRunResult, ClaudeSessionSummary, ClaudeSessionTranscriptMessage, ManagerPromptRegistry, RunClaudeSessionInput, SessionContextSnapshot, GitDiffResult, GitOperationResult, PersistentRunRecord, PersistentRunResult, ActiveSessionState, ContextWarningLevel, SessionMode, 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;
+        mode?: 'plan' | 'free';
         abortSignal?: AbortSignal;
     }, onEvent?: ClaudeSessionEventHandler): Promise<{
         sessionId: string | undefined;

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

@@ -1,12 +1,16 @@
 import type { ClaudeAgentSdkAdapter, ClaudeSessionEventHandler } from '../claude/claude-agent-sdk-adapter.js';
-import type { ClaudeSessionRunResult, SessionContextSnapshot } from '../types/contracts.js';
+import type { ClaudeSessionRunResult, SessionContextSnapshot, SessionMode } from '../types/contracts.js';
 import type { ContextTracker } from './context-tracker.js';
 export declare class SessionController {
     private readonly sdkAdapter;
     private readonly contextTracker;
     private readonly sessionPrompt;
+    private readonly modePrefixes;
     private activeSessionId;
-    constructor(sdkAdapter: ClaudeAgentSdkAdapter, contextTracker: ContextTracker, sessionPrompt: string);
+    constructor(sdkAdapter: ClaudeAgentSdkAdapter, contextTracker: ContextTracker, sessionPrompt: string, modePrefixes?: {
+        plan: string;
+        free: string;
+    });
     get isActive(): boolean;
     get sessionId(): string | null;
     /**
@@ -15,6 +19,8 @@ export declare class SessionController {
      */
     sendMessage(cwd: string, message: string, options?: {
         model?: string;
+        effort?: 'low' | 'medium' | 'high' | 'max';
+        mode?: SessionMode;
         settingSources?: Array<'user' | 'project' | 'local'>;
         abortSignal?: AbortSignal;
     }, onEvent?: ClaudeSessionEventHandler): Promise<ClaudeSessionRunResult>;

package/dist/manager/session-controller.js

@@ -5,11 +5,16 @@ export class SessionController {
     sdkAdapter;
     contextTracker;
     sessionPrompt;
+    modePrefixes;
     activeSessionId = null;
-    constructor(sdkAdapter, contextTracker, sessionPrompt) {
+    constructor(sdkAdapter, contextTracker, sessionPrompt, modePrefixes = {
+        plan: '',
+        free: '',
+    }) {
         this.sdkAdapter = sdkAdapter;
         this.contextTracker = contextTracker;
         this.sessionPrompt = sessionPrompt;
+        this.modePrefixes = modePrefixes;
     }
     get isActive() {
         return this.activeSessionId !== null;
@@ -22,13 +27,17 @@ export class SessionController {
      * Returns the session result including usage data.
      */
     async sendMessage(cwd, message, options, onEvent) {
+        const mode = options?.mode ?? 'free';
+        const prefix = this.modePrefixes[mode];
+        const prompt = prefix ? `${prefix}\n\n${message}` : message;
         const input = {
             cwd,
-            prompt: message,
+            prompt,
             persistSession: true,
-            permissionMode: 'acceptEdits',
+            permissionMode: mode === 'plan' ? 'plan' : 'acceptEdits',
             includePartialMessages: true,
             model: options?.model,
+            effort: options?.effort,
             settingSources: options?.settingSources ?? ['user', 'project', 'local'],
             abortSignal: options?.abortSignal,
         };
@@ -37,8 +46,10 @@ export class SessionController {
             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

@@ -107,10 +107,13 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
             claude_manager_send: tool({
                 description: 'Send a message to the persistent Claude Code session. ' +
                     'Auto-creates a session on first call. Resumes the existing session on subsequent calls. ' +
-                    'Returns the assistant response and current context health snapshot.',
+                    'Returns the assistant response and current context health snapshot. ' +
+                    'Use mode "plan" for read-only investigation and planning (no edits), ' +
+                    'or "free" (default) for normal execution with edit permissions.',
                 args: {
                     message: tool.schema.string().min(1),
                     model: tool.schema.string().optional(),
+                    mode: tool.schema.enum(['plan', 'free']).default('free'),
                     cwd: tool.schema.string().optional(),
                 },
                 async execute(args, context) {
@@ -130,7 +133,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     });
                     let turnsSoFar = 0;
                     let costSoFar = 0;
-                    const result = await services.manager.sendMessage(cwd, args.message, { model: args.model, abortSignal: context.abort }, (event) => {
+                    const result = await services.manager.sendMessage(cwd, args.message, { model: args.model, mode: args.mode, abortSignal: context.abort }, (event) => {
                         if (event.turns !== undefined) {
                             turnsSoFar = event.turns;
                         }
@@ -189,6 +192,66 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                                 },
                             });
                         }
+                        else if (event.type === 'user') {
+                            const preview = event.text.length > 200
+                                ? event.text.slice(0, 200) + '...'
+                                : event.text;
+                            context.metadata({
+                                title: `Claude Code: Tool result (${turnsSoFar} turns, ${costLabel})`,
+                                metadata: {
+                                    sessionId: event.sessionId,
+                                    type: event.type,
+                                    output: preview,
+                                },
+                            });
+                        }
+                        else if (event.type === 'tool_progress') {
+                            let toolName = 'tool';
+                            let elapsed = 0;
+                            try {
+                                const parsed = JSON.parse(event.text);
+                                toolName = parsed.name ?? 'tool';
+                                elapsed = parsed.elapsed ?? 0;
+                            }
+                            catch {
+                                // ignore
+                            }
+                            context.metadata({
+                                title: `Claude Code: ${toolName} running ${elapsed > 0 ? `(${elapsed.toFixed(0)}s)` : ''}... (${turnsSoFar} turns, ${costLabel})`,
+                                metadata: {
+                                    sessionId: event.sessionId,
+                                    type: event.type,
+                                    tool: toolName,
+                                    elapsed,
+                                },
+                            });
+                        }
+                        else if (event.type === 'tool_summary') {
+                            const summary = event.text.length > 200
+                                ? event.text.slice(0, 200) + '...'
+                                : event.text;
+                            context.metadata({
+                                title: `Claude Code: Tool done (${turnsSoFar} turns, ${costLabel})`,
+                                metadata: {
+                                    sessionId: event.sessionId,
+                                    type: event.type,
+                                    summary,
+                                },
+                            });
+                        }
+                        else if (event.type === 'partial') {
+                            const delta = event.text.length > 200
+                                ? event.text.slice(0, 200) + '...'
+                                : event.text;
+                            context.metadata({
+                                title: `Claude Code: Writing... (${turnsSoFar} turns, ${costLabel})`,
+                                metadata: {
+                                    sessionId: event.sessionId,
+                                    type: event.type,
+                                    delta,
+                                },
+                            });
+                        }
                         else if (event.type === 'error') {
                             context.metadata({
                                 title: `Claude Code: Error`,
@@ -214,6 +277,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,
@@ -221,6 +294,7 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                         totalCostUsd: result.totalCostUsd,
                         context: result.context,
                         contextWarning,
+                        toolOutputs: toolOutputs.length > 0 ? toolOutputs : undefined,
                     }, null, 2);
                 },
             }),

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

@@ -1,10 +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,6 @@
 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';
@@ -21,17 +22,19 @@ export function getOrCreatePluginServices(worktree) {
     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 sessionController = new SessionController(sdkAdapter, contextTracker, managerPromptRegistry.claudeCodeSessionPrompt, managerPromptRegistry.modePrefixes);
     const gitOps = new GitOperations(worktree);
     const stateStore = new FileRunStateStore();
     const transcriptStore = new TranscriptStore();
     const manager = new PersistentManager(sessionController, gitOps, stateStore, contextTracker, transcriptStore);
     // Try to restore active session state (fire and forget)
     manager.tryRestore(worktree).catch(() => { });
+    const liveTailer = new SessionLiveTailer();
     const services = {
         manager,
         sessions: sessionService,
         approvalManager,
+        liveTailer,
     };
     serviceCache.set(worktree, services);
     return services;

package/dist/prompts/registry.js

@@ -1,42 +1,133 @@
 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'),
+    modePrefixes: {
+        plan: [
+            '[PLAN MODE] You are in read-only planning mode. Do NOT create or edit any files.',
+            'Use read, grep, glob, and search tools only.',
+            'Analyze the codebase and produce a detailed implementation plan:',
+            'files to change, functions to modify, new files to create, test strategy,',
+            'and potential risks. End with a numbered step-by-step plan.',
+        ].join(' '),
+        free: '',
+    },
     contextWarnings: {
         moderate: 'Session context is filling up ({percent}% estimated). Consider whether a fresh session would be more efficient.',
         high: 'Session context is heavy ({percent}% estimated, {turns} turns, ${cost}). Start a new session or compact first.',

package/dist/types/contracts.d.ts

@@ -1,6 +1,10 @@
 export interface ManagerPromptRegistry {
     managerSystemPrompt: string;
     claudeCodeSessionPrompt: string;
+    modePrefixes: {
+        plan: string;
+        free: string;
+    };
     contextWarnings: {
         moderate: string;
         high: string;
@@ -8,6 +12,7 @@ export interface ManagerPromptRegistry {
     };
 }
 export type ClaudeSettingSource = 'user' | 'project' | 'local';
+export type SessionMode = 'plan' | 'free';
 export interface ClaudeCommandMetadata {
     name: string;
     description: string;
@@ -44,7 +49,7 @@ export interface ClaudeMetadataSnapshot {
     settingsPaths: string[];
 }
 export interface ClaudeSessionEvent {
-    type: 'init' | 'assistant' | 'partial' | 'user' | 'tool_call' | 'status' | 'system' | 'result' | 'error';
+    type: 'init' | 'assistant' | 'partial' | 'user' | 'tool_call' | 'tool_progress' | 'tool_summary' | 'status' | 'system' | 'result' | 'error';
     sessionId?: string;
     text: string;
     turns?: number;
@@ -57,6 +62,8 @@ export interface RunClaudeSessionInput {
     prompt: string;
     systemPrompt?: string;
     model?: string;
+    effort?: 'low' | 'medium' | 'high' | 'max';
+    mode?: SessionMode;
     permissionMode?: 'default' | 'acceptEdits' | 'plan' | 'dontAsk';
     allowedTools?: string[];
     disallowedTools?: string[];
@@ -167,6 +174,18 @@ 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;

package/package.json

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