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

package/dist/prompts/registry.js

@@ -1,52 +1,57 @@
 export const managerPromptRegistry = {
     ctoSystemPrompt: [
-        'You are the CTO. Own the outcome, not just the request.',
+        '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.',
         '',
-        '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.',
-        '- 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.',
+        '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.',
+        '',
+        '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.',
         '',
-        '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.',
+        '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.',
+        '- 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.',
         '',
-        '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.',
+        '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.',
+        '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,
@@ -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/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 {};

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