@doingdev/opencode-claude-manager-plugin 0.1.49 → 0.1.50

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

@@ -1,5 +1,5 @@
-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 Options, type Query, type SDKSessionInfo, type SessionMessage } from '@anthropic-ai/claude-agent-sdk';
+import type { 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 {
@@ -21,7 +21,6 @@ export declare class ClaudeAgentSdkAdapter {
     runSession(input: RunClaudeSessionInput, onEvent?: ClaudeSessionEventHandler): Promise<ClaudeSessionRunResult>;
     listSavedSessions(cwd?: string): Promise<ClaudeSessionSummary[]>;
     getTranscript(sessionId: string, cwd?: string): Promise<ClaudeSessionTranscriptMessage[]>;
-    probeCapabilities(cwd: string, settingSources?: SettingSource[]): Promise<ClaudeCapabilitySnapshot>;
     private buildOptions;
 }
 export {};

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

@@ -123,34 +123,6 @@ export class ClaudeAgentSdkAdapter {
             text: extractText(message.message),
         }));
     }
-    async probeCapabilities(cwd, settingSources = ['project']) {
-        const sessionQuery = this.sdkFacade.query({
-            prompt: 'Reply with OK.',
-            options: {
-                cwd,
-                maxTurns: 1,
-                permissionMode: 'plan',
-                persistSession: false,
-                tools: [],
-                settingSources,
-            },
-        });
-        try {
-            const [commands, agents, models] = await Promise.all([
-                sessionQuery.supportedCommands(),
-                sessionQuery.supportedAgents(),
-                sessionQuery.supportedModels(),
-            ]);
-            return {
-                commands: commands.map(mapSlashCommand),
-                agents: agents.map(mapAgent),
-                models: models.map((model) => model.value),
-            };
-        }
-        finally {
-            sessionQuery.close();
-        }
-    }
     buildOptions(input) {
         const options = {
             cwd: input.cwd,
@@ -465,22 +437,6 @@ function extractText(payload) {
     }
     return JSON.stringify(payload);
 }
-function mapSlashCommand(command) {
-    return {
-        name: command.name,
-        description: command.description,
-        argumentHint: command.argumentHint,
-        source: 'sdk',
-    };
-}
-function mapAgent(agent) {
-    return {
-        name: agent.name,
-        description: agent.description,
-        model: agent.model,
-        source: 'sdk',
-    };
-}
 function extractUsageFromResult(message) {
     if (message.type !== 'result') {
         return {};

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

@@ -1,4 +1,4 @@
-import type { ClaudeCapabilitySnapshot, ClaudeSessionRunResult, ClaudeSessionSummary, ClaudeSessionTranscriptMessage, RunClaudeSessionInput } from '../types/contracts.js';
+import type { ClaudeSessionRunResult, ClaudeSessionSummary, ClaudeSessionTranscriptMessage, RunClaudeSessionInput } from '../types/contracts.js';
 import type { ClaudeAgentSdkAdapter, ClaudeSessionEventHandler } from './claude-agent-sdk-adapter.js';
 export declare class ClaudeSessionService {
     private readonly sdkAdapter;
@@ -6,5 +6,4 @@ export declare class ClaudeSessionService {
     runTask(input: RunClaudeSessionInput, onEvent?: ClaudeSessionEventHandler): Promise<ClaudeSessionRunResult>;
     listSessions(cwd?: string): Promise<ClaudeSessionSummary[]>;
     getTranscript(sessionId: string, cwd?: string): Promise<ClaudeSessionTranscriptMessage[]>;
-    probeCapabilities(cwd: string): Promise<ClaudeCapabilitySnapshot>;
 }

package/dist/claude/claude-session.service.js

@@ -12,7 +12,4 @@ export class ClaudeSessionService {
     getTranscript(sessionId, cwd) {
         return this.sdkAdapter.getTranscript(sessionId, cwd);
     }
-    probeCapabilities(cwd) {
-        return this.sdkAdapter.probeCapabilities(cwd);
-    }
 }

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

@@ -3,7 +3,10 @@ export declare class ToolApprovalManager {
     private policy;
     private decisions;
     private readonly maxDecisions;
-    constructor(policy?: Partial<ToolApprovalPolicy>, maxDecisions?: number);
+    private readonly persistPath;
+    constructor(policy?: Partial<ToolApprovalPolicy>, maxDecisions?: number, persistPath?: string);
+    loadPersistedPolicy(): Promise<void>;
+    private persistPolicy;
     evaluate(toolName: string, input: Record<string, unknown>, options?: {
         title?: string;
         agentID?: string;
@@ -17,11 +20,11 @@ export declare class ToolApprovalManager {
     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;
+    setPolicy(policy: ToolApprovalPolicy): Promise<void>;
+    addRule(rule: ToolApprovalRule, position?: number): Promise<void>;
+    removeRule(ruleId: string): Promise<boolean>;
+    setDefaultAction(action: 'allow' | 'deny'): Promise<void>;
+    setEnabled(enabled: boolean): Promise<void>;
     private findMatchingRule;
     private recordDecision;
 }

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

@@ -1,3 +1,6 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { isFileNotFoundError, writeJsonAtomically } from '../util/fs-helpers.js';
 const DEFAULT_MAX_DECISIONS = 500;
 const INPUT_PREVIEW_MAX = 300;
 function getDefaultRules() {
@@ -120,7 +123,8 @@ export class ToolApprovalManager {
     policy;
     decisions = [];
     maxDecisions;
-    constructor(policy, maxDecisions) {
+    persistPath;
+    constructor(policy, maxDecisions, persistPath) {
         this.policy = {
             rules: policy?.rules ?? getDefaultRules(),
             defaultAction: policy?.defaultAction ?? 'allow',
@@ -128,6 +132,34 @@ export class ToolApprovalManager {
             enabled: policy?.enabled ?? true,
         };
         this.maxDecisions = maxDecisions ?? DEFAULT_MAX_DECISIONS;
+        this.persistPath = persistPath ?? null;
+    }
+    async loadPersistedPolicy() {
+        if (!this.persistPath) {
+            return;
+        }
+        try {
+            const content = await fs.readFile(this.persistPath, 'utf8');
+            const loaded = JSON.parse(content);
+            this.policy = {
+                rules: loaded.rules ?? getDefaultRules(),
+                defaultAction: loaded.defaultAction ?? 'allow',
+                defaultDenyMessage: loaded.defaultDenyMessage ?? 'Tool call denied by approval policy.',
+                enabled: loaded.enabled ?? true,
+            };
+        }
+        catch (error) {
+            if (!isFileNotFoundError(error)) {
+                throw error;
+            }
+        }
+    }
+    async persistPolicy() {
+        if (!this.persistPath) {
+            return;
+        }
+        await fs.mkdir(path.dirname(this.persistPath), { recursive: true });
+        await writeJsonAtomically(this.persistPath, this.policy);
     }
     evaluate(toolName, input, options) {
         if (!this.policy.enabled) {
@@ -168,30 +200,35 @@ export class ToolApprovalManager {
     getPolicy() {
         return { ...this.policy, rules: [...this.policy.rules] };
     }
-    setPolicy(policy) {
+    async setPolicy(policy) {
         this.policy = { ...policy, rules: [...policy.rules] };
+        await this.persistPolicy();
     }
-    addRule(rule, position) {
+    async 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);
         }
+        await this.persistPolicy();
     }
-    removeRule(ruleId) {
+    async removeRule(ruleId) {
         const index = this.policy.rules.findIndex((r) => r.id === ruleId);
         if (index === -1) {
             return false;
         }
         this.policy.rules.splice(index, 1);
+        await this.persistPolicy();
         return true;
     }
-    setDefaultAction(action) {
+    async setDefaultAction(action) {
         this.policy.defaultAction = action;
+        await this.persistPolicy();
     }
-    setEnabled(enabled) {
+    async setEnabled(enabled) {
         this.policy.enabled = enabled;
+        await this.persistPolicy();
     }
     findMatchingRule(toolName, inputJson) {
         for (const rule of this.policy.rules) {

package/dist/index.d.ts

@@ -1,6 +1,5 @@
 import type { Plugin } from '@opencode-ai/plugin';
 import { ClaudeManagerPlugin } from './plugin/claude-manager.plugin.js';
-export type { ClaudeCapabilitySnapshot, ClaudeSessionRunResult, ClaudeSessionSummary, ClaudeSessionTranscriptMessage, ManagerPromptRegistry, RunClaudeSessionInput, SessionContextSnapshot, GitDiffResult, GitOperationResult, PersistentRunRecord, PersistentRunResult, ContextWarningLevel, SessionMode, EngineerName, EngineerWorkMode, WrapperHistoryEntry, TeamEngineerRecord, TeamRecord, EngineerTaskResult, PlanDraft, SynthesizedPlanResult, LiveTailEvent, ToolOutputPreview, ToolApprovalRule, ToolApprovalPolicy, ToolApprovalDecision, } from './types/contracts.js';
-export { SessionLiveTailer } from './claude/session-live-tailer.js';
+export type { ClaudeCapabilitySnapshot, ClaudeSessionRunResult, ClaudeSessionSummary, ClaudeSessionTranscriptMessage, ManagerPromptRegistry, RunClaudeSessionInput, SessionContextSnapshot, GitDiffResult, GitOperationResult, ContextWarningLevel, SessionMode, EngineerName, EngineerWorkMode, EngineerFailureKind, EngineerFailureResult, WrapperHistoryEntry, TeamEngineerRecord, TeamRecord, EngineerTaskResult, PlanDraft, SynthesizedPlanResult, ToolApprovalRule, ToolApprovalPolicy, ToolApprovalDecision, } from './types/contracts.js';
 export { ClaudeManagerPlugin };
 export declare const plugin: Plugin;

package/dist/index.js

@@ -1,4 +1,3 @@
 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/context-tracker.d.ts

@@ -19,7 +19,6 @@ export declare class ContextTracker {
     snapshot(): SessionContextSnapshot;
     warningLevel(): ContextWarningLevel;
     estimateContextPercent(): number | null;
-    isAboveTokenThreshold(thresholdTokens?: number): boolean;
     reset(): void;
     /** Restore from persisted active session state. */
     restore(state: {

package/dist/manager/context-tracker.js

@@ -83,9 +83,6 @@ export class ContextTracker {
         }
         return null;
     }
-    isAboveTokenThreshold(thresholdTokens = 200_000) {
-        return this.latestInputTokens !== null && this.latestInputTokens >= thresholdTokens;
-    }
     reset() {
         this.totalTurns = 0;
         this.totalCostUsd = 0;

package/dist/manager/git-operations.d.ts

@@ -7,15 +7,12 @@ export declare class GitOperations {
         staged?: boolean;
         ref?: string;
     }): Promise<GitDiffResult>;
-    diffStat(): Promise<string>;
-    commit(message: string): Promise<GitOperationResult>;
+    commit(message: string, paths?: string[]): Promise<GitOperationResult>;
     resetHard(): Promise<GitOperationResult>;
     status(): Promise<{
         output: string;
         isClean: boolean;
     }>;
     log(count?: number): Promise<string>;
-    currentBranch(): Promise<string>;
-    recentCommits(count?: number): Promise<string>;
     private git;
 }

package/dist/manager/git-operations.js

@@ -23,12 +23,14 @@ export class GitOperations {
             stats,
         };
     }
-    async diffStat() {
-        return this.git(['diff', 'HEAD', '--stat']);
-    }
-    async commit(message) {
+    async commit(message, paths) {
         try {
-            await this.git(['add', '-A']);
+            if (paths && paths.length > 0) {
+                await this.git(['add', '--', ...paths]);
+            }
+            else {
+                await this.git(['add', '-A']);
+            }
             const output = await this.git(['commit', '-m', message]);
             return { success: true, output };
         }
@@ -65,13 +67,6 @@ export class GitOperations {
     async log(count = 5) {
         return this.git(['log', '--oneline', `-${count}`]);
     }
-    async currentBranch() {
-        const branch = await this.git(['rev-parse', '--abbrev-ref', 'HEAD']);
-        return branch.trim();
-    }
-    async recentCommits(count = 5) {
-        return this.git(['log', `--oneline`, `-${count}`]);
-    }
     async git(args) {
         const { stdout } = await execFileAsync('git', args, { cwd: this.cwd });
         return stdout;

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

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

package/dist/manager/persistent-manager.js

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

package/dist/manager/team-orchestrator.d.ts

@@ -2,7 +2,7 @@ import type { ClaudeSessionEventHandler } from '../claude/claude-agent-sdk-adapt
 import type { ClaudeSessionService } from '../claude/claude-session.service.js';
 import type { TeamStateStore } from '../state/team-state-store.js';
 import type { TranscriptStore } from '../state/transcript-store.js';
-import type { DiscoveredClaudeFile, EngineerName, EngineerTaskResult, EngineerWorkMode, SynthesizedPlanResult, TeamRecord } from '../types/contracts.js';
+import type { DiscoveredClaudeFile, EngineerFailureResult, EngineerName, EngineerTaskResult, EngineerWorkMode, SynthesizedPlanResult, TeamRecord } from '../types/contracts.js';
 interface DispatchEngineerInput {
     teamId: string;
     cwd: string;
@@ -29,7 +29,14 @@ export declare class TeamOrchestrator {
         teamId: string;
         engineer: EngineerName;
     } | null>;
+    resetEngineer(cwd: string, teamId: string, engineer: EngineerName, options?: {
+        clearSession?: boolean;
+        clearHistory?: boolean;
+    }): Promise<void>;
     dispatchEngineer(input: DispatchEngineerInput): Promise<EngineerTaskResult>;
+    static classifyError(error: unknown): EngineerFailureResult & {
+        cause: unknown;
+    };
     planWithTeam(input: {
         teamId: string;
         cwd: string;