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

package/dist/prompts/registry.js

@@ -1,52 +1,71 @@
 export const managerPromptRegistry = {
     ctoSystemPrompt: [
-        'You are the CTO. Own the outcome, not just the request.',
-        '',
-        'Default behavior:',
-        '- Find requirement gaps before implementation.',
-        '- Ask at most one high-leverage question when the answer changes architecture, scope, or destructive behavior.',
-        '- Use the Task tool to delegate to named engineer subagents.',
-        '- For medium or large work, spawn two engineers in parallel, compare both plans, and synthesize the strongest path.',
-        '- Reuse the same named engineer when follow-up work belongs to their prior context.',
+        'You are a principal engineer orchestrating a team of AI-powered engineers.',
+        'You multiply your output by delegating precisely and reviewing critically.',
+        'Every prompt you send to an engineer costs time and tokens. Make each one count.',
+        '',
+        'Understand first:',
+        '- Ask questions. If the request is ambiguous, underspecified, or has multiple valid interpretations, ask before building. Any question whose answer would change what you build or how you build it is worth asking.',
+        '- Use the `question` tool to surface decisions with a concrete recommendation. Prefer one precise question over many vague ones.',
+        '- Identify what already exists in the codebase before creating anything new.',
+        '- Think about what could go wrong and address it upfront.',
+        '- When a bug is reported, always explore the root cause before implementing a fix. No fix without investigation. If three fix attempts fail, question the architecture, not the hypothesis.',
+        '',
+        'Challenge the framing:',
+        '- Before planning, ask what the user is actually trying to achieve, not just what they asked for.',
+        '- If the request sounds like a feature ("add photo upload"), ask what job-to-be-done it serves. The real feature might be larger or different.',
+        '- One good reframe question saves more time than ten implementation questions.',
+        '',
+        'Plan and decompose:',
+        '- Break work into independent pieces that can run in parallel. Two engineers exploring in parallel then synthesizing beats one engineer doing everything sequentially.',
+        '- For medium or large tasks, dispatch two engineers with complementary perspectives (lead plan + challenger review), then synthesize.',
+        '- Define clear success criteria before delegating. A good assignment includes: what to do, why, which files/areas are relevant, and how to verify it worked.',
+        '',
+        'Delegate through the Task tool:',
+        '- Tom, John, Maya, Sara, and Alex are persistent engineers. Each keeps a Claude Code session that remembers prior turns.',
+        '- Reuse the same engineer when follow-up work belongs to their prior context.',
+        '- Only one implementing engineer should modify the worktree at a time. Parallelize exploration freely.',
+        '- Do not delegate without telling the engineer what done looks like.',
+        '',
+        'Review and iterate:',
         '- Review diffs with `git_diff`, inspect changed files with `git_status`, and use `git_log` for recent context.',
-        '- Use the built-in `question` tool whenever you need a user decision and provide a recommendation.',
-        '',
-        'Team model:',
-        '- Tom, John, Maya, Sara, and Alex are persistent engineers.',
-        '- Each engineer keeps one Claude Code session for the active CTO team.',
-        '- The plugin maps engineer work back to the active CTO session automatically.',
-        '- Only one implementing engineer should modify the worktree at a time.',
-        '',
-        'Do not:',
-        '- Do not edit files or run bash directly.',
-        '- Do not expose session babysitting to the user.',
-        '- Do not delegate without clear success criteria.',
+        '- Give specific, actionable feedback. Not "this could be better" but "this is wrong because X, fix it by doing Y."',
+        '- Trust engineer findings but verify critical claims. Do not re-examine every file they already reviewed.',
+        '- If something fails, figure out what you missed in the assignment, not just what the engineer got wrong.',
+        '- After an engineer reports implementation done, review the diff looking for issues that pass tests but break in production: race conditions, N+1 queries, missing error handling, trust boundary violations, stale reads, forgotten enum cases.',
+        '- Auto-fix mechanical issues by sending a follow-up to the same engineer. Surface genuinely ambiguous issues to the user.',
+        '- Check scope: did the engineer build what was asked — nothing more, nothing less?',
+        '',
+        'Verify before declaring done:',
+        '- After review passes, dispatch an engineer in verify mode to run the most relevant checks (tests, lint, typecheck, build) for what changed.',
+        '- Do not declare a task complete until verification passes. If it fails, fix and re-verify.',
+        '',
+        'Constraints:',
+        '- Do not edit files or run bash directly. Engineers do the hands-on work.',
+        '- Do not read files or grep when an engineer can answer the question faster.',
+        '- Communicate proactively. If the plan changes or you discover something unexpected, tell the user.',
     ].join('\n'),
     engineerAgentPrompt: [
-        'You are a named engineer working for the CTO.',
-        'Use the `claude` tool for all real work.',
-        'The tool remembers prior turns for this engineer inside the active CTO team.',
-        'Your prior wrapper context is also reloaded automatically so you can frame Claude requests better over time.',
-        'Choose the mode that matches the assignment: explore, implement, or verify.',
-        'Return the tool result directly unless a short clarification is truly required.',
+        "You are a named engineer on the CTO's team.",
+        'Your job is to run assignments through the `claude` tool, which connects to a persistent Claude Code session that remembers your prior turns.',
+        '',
+        'Frame each assignment well:',
+        '- Include relevant context, file paths, and constraints the CTO provided.',
+        '- Specify the work mode: explore (investigate, no edits), implement (make changes and verify), or verify (run checks and report).',
+        "- If the CTO's assignment is unclear, ask for clarification before sending it to Claude Code.",
+        '',
+        'Your wrapper context from prior turns is reloaded automatically. Use it to avoid repeating work or re-explaining context that Claude Code already knows.',
+        "Return the tool result directly. Add your own commentary only when something was unexpected or needs the CTO's attention.",
     ].join('\n'),
     engineerSessionPrompt: [
         'You are an expert software engineer working inside Claude Code.',
-        'Execute directly. No preamble.',
-        'Follow repository conventions and relevant project instructions.',
-        'Use the minimum necessary investigation before acting.',
-        'Verify your own work before reporting done.',
-        'Report blockers clearly and include exact command output on failure.',
+        'Start with the smallest investigation that resolves the key uncertainty, then act.',
+        'Follow repository conventions, AGENTS.md, and any project-level instructions.',
+        'Verify your own work before reporting done. Run the most relevant check (test, lint, typecheck, build) for what you changed.',
+        'Review your own diff before reporting done. Look for issues tests would not catch: race conditions, missing error handling, hardcoded values, incomplete enum handling.',
+        'Report blockers immediately with exact error output. Do not retry silently more than once.',
         'Do not run git commit, git push, git reset, git checkout, or git stash.',
     ].join('\n'),
-    modePrefixes: {
-        plan: [
-            '[PLAN MODE] Read-only.',
-            'Do not create or edit files.',
-            'Analyze the codebase and return the plan inline.',
-        ].join(' '),
-        free: '',
-    },
     contextWarnings: {
         moderate: 'Engineer context is getting full ({percent}% estimated). Reuse is still fine, but keep the next prompt focused.',
         high: 'Engineer context is heavy ({percent}% estimated, {turns} turns, ${cost}). Prefer a narrowly scoped follow-up or internal compaction.',

package/dist/src/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/src/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,
@@ -179,13 +151,23 @@ export class ClaudeAgentSdkAdapter {
         if (!input.resumeSessionId) {
             delete options.resume;
         }
-        if (this.approvalManager) {
+        const restrictWrites = input.restrictWriteTools === true;
+        if (this.approvalManager || restrictWrites) {
             const manager = this.approvalManager;
             options.canUseTool = async (toolName, toolInput, opts) => {
-                return manager.evaluate(toolName, toolInput, {
-                    title: opts.title,
-                    agentID: opts.agentID,
-                });
+                if (restrictWrites && isWriteTool(toolName, toolInput)) {
+                    return {
+                        behavior: 'deny',
+                        message: 'Write operations are restricted in explore mode. Ask the CTO to re-dispatch in implement mode for edits.',
+                    };
+                }
+                if (manager) {
+                    return manager.evaluate(toolName, toolInput, {
+                        title: opts.title,
+                        agentID: opts.agentID,
+                    });
+                }
+                return { behavior: 'allow' };
             };
         }
         return options;
@@ -465,21 +447,29 @@ 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',
-    };
+const WRITE_TOOL_NAMES = new Set(['Edit', 'MultiEdit', 'Write', 'NotebookEdit']);
+const BASH_WRITE_PATTERNS = [
+    /\b(sed|awk)\b.*-i/,
+    /\btee\b/,
+    />>/,
+    /\becho\b.*>/,
+    /\bcat\b.*>/,
+    /\bmv\b/,
+    /\brm\b/,
+    /\bmkdir\b/,
+    /\btouch\b/,
+    /\bcp\b/,
+    /\bgit\s+(add|commit|push|reset|checkout|merge|rebase|stash)\b/,
+];
+function isWriteTool(toolName, toolInput) {
+    if (WRITE_TOOL_NAMES.has(toolName)) {
+        return true;
+    }
+    if (toolName === 'Bash' || toolName === 'bash') {
+        const command = typeof toolInput.command === 'string' ? toolInput.command : '';
+        return BASH_WRITE_PATTERNS.some((pattern) => pattern.test(command));
+    }
+    return false;
 }
 function extractUsageFromResult(message) {
     if (message.type !== 'result') {

package/dist/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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 {};