@doingdev/opencode-claude-manager-plugin 0.1.9 → 0.1.11

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import type { Plugin } from '@opencode-ai/plugin';
 import { ClaudeManagerPlugin } from './plugin/claude-manager.plugin.js';
-export type { ClaudeCapabilitySnapshot, ClaudeMetadataSnapshot, ClaudeSessionRunResult, ClaudeSessionSummary, ClaudeSessionTranscriptMessage, ManagerRunRecord, ManagerRunResult, ManagerTaskRequest, ManagerPromptRegistry, RunClaudeSessionInput, } from './types/contracts.js';
+export type { ClaudeCapabilitySnapshot, ClaudeMetadataSnapshot, ClaudeSessionRunResult, ClaudeSessionSummary, ClaudeSessionTranscriptMessage, ManagerPromptRegistry, RunClaudeSessionInput, SessionContextSnapshot, GitDiffResult, GitOperationResult, PersistentRunRecord, PersistentRunResult, ActiveSessionState, ContextWarningLevel, } from './types/contracts.js';
 export { ClaudeManagerPlugin };
 export declare const plugin: Plugin;

package/dist/manager/context-tracker.d.ts

@@ -0,0 +1,33 @@
+import type { ContextWarningLevel, SessionContextSnapshot } from '../types/contracts.js';
+export declare class ContextTracker {
+    private totalTurns;
+    private totalCostUsd;
+    private latestInputTokens;
+    private latestOutputTokens;
+    private contextWindowSize;
+    private compactionCount;
+    private sessionId;
+    recordResult(result: {
+        sessionId?: string;
+        turns?: number;
+        totalCostUsd?: number;
+        inputTokens?: number;
+        outputTokens?: number;
+        contextWindowSize?: number;
+    }): void;
+    recordCompaction(): void;
+    snapshot(): SessionContextSnapshot;
+    warningLevel(): ContextWarningLevel;
+    estimateContextPercent(): number | null;
+    isAboveTokenThreshold(thresholdTokens?: number): boolean;
+    reset(): void;
+    /** Restore from persisted active session state. */
+    restore(state: {
+        sessionId: string;
+        totalTurns: number;
+        totalCostUsd: number;
+        estimatedContextPercent: number | null;
+        contextWindowSize: number | null;
+        latestInputTokens: number | null;
+    }): void;
+}

package/dist/manager/context-tracker.js

@@ -0,0 +1,108 @@
+const DEFAULT_CONTEXT_WINDOW = 200_000;
+export class ContextTracker {
+    totalTurns = 0;
+    totalCostUsd = 0;
+    latestInputTokens = null;
+    latestOutputTokens = null;
+    contextWindowSize = null;
+    compactionCount = 0;
+    sessionId = null;
+    recordResult(result) {
+        if (result.sessionId) {
+            this.sessionId = result.sessionId;
+        }
+        if (result.turns !== undefined) {
+            this.totalTurns = result.turns;
+        }
+        if (result.totalCostUsd !== undefined) {
+            this.totalCostUsd = result.totalCostUsd;
+        }
+        if (result.inputTokens !== undefined) {
+            // If input tokens dropped significantly, compaction likely occurred
+            if (this.latestInputTokens !== null &&
+                result.inputTokens < this.latestInputTokens * 0.5) {
+                this.compactionCount++;
+            }
+            this.latestInputTokens = result.inputTokens;
+        }
+        if (result.outputTokens !== undefined) {
+            this.latestOutputTokens = result.outputTokens;
+        }
+        if (result.contextWindowSize !== undefined) {
+            this.contextWindowSize = result.contextWindowSize;
+        }
+    }
+    recordCompaction() {
+        this.compactionCount++;
+    }
+    snapshot() {
+        return {
+            sessionId: this.sessionId,
+            totalTurns: this.totalTurns,
+            totalCostUsd: this.totalCostUsd,
+            latestInputTokens: this.latestInputTokens,
+            latestOutputTokens: this.latestOutputTokens,
+            contextWindowSize: this.contextWindowSize,
+            estimatedContextPercent: this.estimateContextPercent(),
+            warningLevel: this.warningLevel(),
+            compactionCount: this.compactionCount,
+        };
+    }
+    warningLevel() {
+        const percent = this.estimateContextPercent();
+        if (percent === null) {
+            return 'ok';
+        }
+        if (percent >= 85) {
+            return 'critical';
+        }
+        if (percent >= 70) {
+            return 'high';
+        }
+        if (percent >= 50) {
+            return 'moderate';
+        }
+        return 'ok';
+    }
+    estimateContextPercent() {
+        // Tier 1: Token-based (most accurate)
+        if (this.latestInputTokens !== null) {
+            const window = this.contextWindowSize ?? DEFAULT_CONTEXT_WINDOW;
+            return Math.min(100, Math.round((this.latestInputTokens / window) * 100));
+        }
+        // Tier 2: Cost-based heuristic
+        if (this.totalCostUsd > 0) {
+            const estimatedTokens = this.totalCostUsd * 130_000;
+            const window = this.contextWindowSize ?? DEFAULT_CONTEXT_WINDOW;
+            return Math.min(100, Math.round((estimatedTokens / window) * 100));
+        }
+        // Tier 3: Turns-based fallback
+        if (this.totalTurns > 0) {
+            const estimatedTokens = this.totalTurns * 6_000;
+            const window = this.contextWindowSize ?? DEFAULT_CONTEXT_WINDOW;
+            return Math.min(100, Math.round((estimatedTokens / window) * 100));
+        }
+        return null;
+    }
+    isAboveTokenThreshold(thresholdTokens = 200_000) {
+        return (this.latestInputTokens !== null &&
+            this.latestInputTokens >= thresholdTokens);
+    }
+    reset() {
+        this.totalTurns = 0;
+        this.totalCostUsd = 0;
+        this.latestInputTokens = null;
+        this.latestOutputTokens = null;
+        this.contextWindowSize = null;
+        this.compactionCount = 0;
+        this.sessionId = null;
+    }
+    /** Restore from persisted active session state. */
+    restore(state) {
+        this.sessionId = state.sessionId;
+        this.totalTurns = state.totalTurns;
+        this.totalCostUsd = state.totalCostUsd;
+        this.contextWindowSize = state.contextWindowSize;
+        this.latestInputTokens = state.latestInputTokens;
+    }
+}

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

@@ -0,0 +1,12 @@
+import type { GitDiffResult, GitOperationResult } from '../types/contracts.js';
+export declare class GitOperations {
+    private readonly cwd;
+    constructor(cwd: string);
+    diff(): Promise<GitDiffResult>;
+    diffStat(): Promise<string>;
+    commit(message: string): Promise<GitOperationResult>;
+    resetHard(): Promise<GitOperationResult>;
+    currentBranch(): Promise<string>;
+    recentCommits(count?: number): Promise<string>;
+    private git;
+}

package/dist/manager/git-operations.js

@@ -0,0 +1,76 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+export class GitOperations {
+    cwd;
+    constructor(cwd) {
+        this.cwd = cwd;
+    }
+    async diff() {
+        const [diffText, statOutput] = await Promise.all([
+            this.git(['diff', 'HEAD']),
+            this.git(['diff', 'HEAD', '--stat']),
+        ]);
+        const stats = parseStatLine(statOutput);
+        return {
+            hasDiff: diffText.trim().length > 0,
+            diffText,
+            stats,
+        };
+    }
+    async diffStat() {
+        return this.git(['diff', 'HEAD', '--stat']);
+    }
+    async commit(message) {
+        try {
+            await this.git(['add', '-A']);
+            const output = await this.git(['commit', '-m', message]);
+            return { success: true, output };
+        }
+        catch (error) {
+            return {
+                success: false,
+                output: '',
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async resetHard() {
+        try {
+            const output = await this.git(['reset', '--hard', 'HEAD']);
+            // Also clean untracked files
+            const cleanOutput = await this.git(['clean', '-fd']);
+            return { success: true, output: `${output}\n${cleanOutput}`.trim() };
+        }
+        catch (error) {
+            return {
+                success: false,
+                output: '',
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    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;
+    }
+}
+function parseStatLine(statOutput) {
+    // Parse the summary line like: "3 files changed, 10 insertions(+), 2 deletions(-)"
+    const summaryLine = statOutput.trim().split('\n').pop() ?? '';
+    const filesMatch = summaryLine.match(/(\d+)\s+files?\s+changed/);
+    const insertionsMatch = summaryLine.match(/(\d+)\s+insertions?\(\+\)/);
+    const deletionsMatch = summaryLine.match(/(\d+)\s+deletions?\(-\)/);
+    return {
+        filesChanged: filesMatch ? parseInt(filesMatch[1], 10) : 0,
+        insertions: insertionsMatch ? parseInt(insertionsMatch[1], 10) : 0,
+        deletions: deletionsMatch ? parseInt(deletionsMatch[1], 10) : 0,
+    };
+}

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

@@ -1,19 +1,16 @@
 import type { ClaudeSessionService } from '../claude/claude-session.service.js';
 import type { FileRunStateStore } from '../state/file-run-state-store.js';
 import type { ManagerRunRecord, ManagerRunResult, ManagerTaskRequest } from '../types/contracts.js';
-import type { WorktreeCoordinator } from '../worktree/worktree-coordinator.js';
 import type { TaskPlanner } from './task-planner.js';
 export type ManagerRunProgressHandler = (run: ManagerRunRecord) => void | Promise<void>;
 export declare class ManagerOrchestrator {
     private readonly sessionService;
     private readonly stateStore;
-    private readonly worktreeCoordinator;
     private readonly taskPlanner;
-    constructor(sessionService: ClaudeSessionService, stateStore: FileRunStateStore, worktreeCoordinator: WorktreeCoordinator, taskPlanner: TaskPlanner);
+    constructor(sessionService: ClaudeSessionService, stateStore: FileRunStateStore, taskPlanner: TaskPlanner);
     run(request: ManagerTaskRequest, onProgress?: ManagerRunProgressHandler): Promise<ManagerRunResult>;
     listRuns(cwd: string): Promise<ManagerRunRecord[]>;
     getRun(cwd: string, runId: string): Promise<ManagerRunRecord | null>;
-    cleanupRunWorktrees(cwd: string, runId: string): Promise<ManagerRunRecord | null>;
     private executePlan;
     private patchSession;
     private updateRunAndNotify;

package/dist/manager/manager-orchestrator.js

@@ -1,65 +1,53 @@
 import { randomUUID } from 'node:crypto';
 import { managerPromptRegistry } from '../prompts/registry.js';
+import { appendTranscriptEvents, stripTrailingPartials, } from '../util/transcript-append.js';
 export class ManagerOrchestrator {
     sessionService;
     stateStore;
-    worktreeCoordinator;
     taskPlanner;
-    constructor(sessionService, stateStore, worktreeCoordinator, taskPlanner) {
+    constructor(sessionService, stateStore, taskPlanner) {
         this.sessionService = sessionService;
         this.stateStore = stateStore;
-        this.worktreeCoordinator = worktreeCoordinator;
         this.taskPlanner = taskPlanner;
     }
     async run(request, onProgress) {
-        const mode = request.mode ?? 'auto';
         const maxSubagents = Math.max(1, request.maxSubagents ?? 3);
-        const useWorktrees = request.useWorktrees ?? maxSubagents > 1;
         const includeProjectSettings = request.includeProjectSettings ?? true;
         const metadata = await this.sessionService.inspectRepository(request.cwd);
-        const plans = this.taskPlanner.plan(request.task, mode, maxSubagents);
+        const plans = this.taskPlanner.plan(request.task, maxSubagents);
         const runId = randomUUID();
         const createdAt = new Date().toISOString();
-        const assignments = await Promise.all(plans.map((plan) => this.worktreeCoordinator.prepareAssignment({
-            cwd: request.cwd,
-            runId,
-            title: plan.title,
-            useWorktree: useWorktrees && plans.length > 1,
-        })));
-        const plannedAssignments = plans.map((plan, index) => ({
+        const plannedAssignments = plans.map((plan) => ({
             plan,
-            assignment: assignments[index],
+            cwd: request.cwd,
         }));
         const runRecord = {
             id: runId,
             cwd: request.cwd,
             task: request.task,
-            mode,
-            useWorktrees,
             includeProjectSettings,
             status: 'running',
             createdAt,
             updatedAt: createdAt,
             metadata,
-            sessions: plannedAssignments.map(({ plan, assignment }) => createManagedSessionRecord(plan, assignment.cwd, assignment)),
+            sessions: plannedAssignments.map(({ plan, cwd }) => createManagedSessionRecord(plan, cwd)),
         };
         await this.stateStore.saveRun(runRecord);
         await onProgress?.(runRecord);
-        const canRunInParallel = plannedAssignments.every(({ assignment }) => assignment.mode === 'git-worktree');
-        const settledResults = canRunInParallel
-            ? await Promise.allSettled(plannedAssignments.map(({ plan, assignment }) => this.executePlan({
+        const settledResults = plannedAssignments.length <= 1
+            ? await Promise.allSettled(plannedAssignments.map(({ plan, cwd }) => this.executePlan({
                 request,
                 runId,
                 plan,
-                assignment,
+                cwd,
                 includeProjectSettings,
                 onProgress,
             })))
-            : await runSequentially(plannedAssignments.map(({ plan, assignment }) => () => this.executePlan({
+            : await runSequentially(plannedAssignments.map(({ plan, cwd }) => () => this.executePlan({
                 request,
                 runId,
                 plan,
-                assignment,
+                cwd,
                 includeProjectSettings,
                 onProgress,
             })));
@@ -78,43 +66,28 @@ export class ManagerOrchestrator {
     getRun(cwd, runId) {
         return this.stateStore.getRun(cwd, runId);
     }
-    async cleanupRunWorktrees(cwd, runId) {
-        const run = await this.stateStore.getRun(cwd, runId);
-        if (!run) {
-            return null;
-        }
-        for (const session of run.sessions) {
-            if (session.worktreeMode !== 'git-worktree') {
-                continue;
-            }
-            await this.worktreeCoordinator.cleanupAssignment({
-                mode: 'git-worktree',
-                cwd: session.cwd,
-                rootCwd: run.cwd,
-                branchName: session.branchName,
-            });
-        }
-        return run;
-    }
     async executePlan(input) {
-        const { request, runId, plan, assignment, includeProjectSettings, onProgress, } = input;
+        const { request, runId, plan, cwd, includeProjectSettings, onProgress } = input;
         await this.patchSession(request.cwd, runId, plan.id, (session) => ({
             ...session,
             status: 'running',
         }), onProgress);
         try {
-            const sessionResult = await this.sessionService.runTask({
-                cwd: assignment.cwd,
+            const sessionInput = {
+                cwd,
                 prompt: buildWorkerPrompt(plan.prompt, request.task),
                 systemPrompt: managerPromptRegistry.subagentSystemPrompt,
                 model: request.model,
                 includePartialMessages: true,
                 settingSources: includeProjectSettings ? ['project', 'local'] : [],
-            }, async (event) => {
+            };
+            const sessionResult = await this.sessionService.runTask(sessionInput, async (event) => {
                 await this.patchSession(request.cwd, runId, plan.id, (session) => ({
                     ...session,
                     claudeSessionId: event.sessionId ?? session.claudeSessionId,
-                    events: [...session.events, compactEvent(event)],
+                    events: appendTranscriptEvents(session.events, [
+                        compactEvent(event),
+                    ]),
                 }), onProgress);
             });
             await this.patchSession(request.cwd, runId, plan.id, (session) => ({
@@ -124,6 +97,7 @@ export class ManagerOrchestrator {
                 finalText: sessionResult.finalText,
                 turns: sessionResult.turns,
                 totalCostUsd: sessionResult.totalCostUsd,
+                events: stripTrailingPartials(session.events),
             }), onProgress);
         }
         catch (error) {
@@ -131,6 +105,7 @@ export class ManagerOrchestrator {
                 ...session,
                 status: 'failed',
                 error: error instanceof Error ? error.message : String(error),
+                events: stripTrailingPartials(session.events),
             }), onProgress);
             throw error;
         }
@@ -148,22 +123,23 @@ export class ManagerOrchestrator {
         return updatedRun;
     }
 }
-function createManagedSessionRecord(plan, cwd, assignment) {
+function createManagedSessionRecord(plan, cwd) {
     return {
         id: plan.id,
         title: plan.title,
         prompt: plan.prompt,
         status: 'pending',
         cwd,
-        worktreeMode: assignment.mode,
-        branchName: assignment.branchName,
         events: [],
     };
 }
-function buildWorkerPrompt(subtaskPrompt, parentTask) {
+function buildWorkerPrompt(subtaskPrompt, parentTasks) {
+    const parentContext = parentTasks.length === 1
+        ? `Parent task: ${parentTasks[0]}`
+        : `Parent tasks:\n${parentTasks.map((t, i) => `${i + 1}. ${t}`).join('\n')}`;
     return [
         'You are executing a delegated Claude Code subtask.',
-        `Parent task: ${parentTask}`,
+        parentContext,
         `Assigned subtask: ${subtaskPrompt}`,
         'Stay within scope, finish the requested work, and end with a concise verification summary.',
     ].join('\n\n');
@@ -174,10 +150,18 @@ function summarizeRun(sessions) {
         .join('\n');
 }
 function compactEvent(event) {
-    return {
-        ...event,
+    const compact = {
+        type: event.type,
+        sessionId: event.sessionId,
         text: event.text.slice(0, 4000),
     };
+    if (event.turns !== undefined) {
+        compact.turns = event.turns;
+    }
+    if (event.totalCostUsd !== undefined) {
+        compact.totalCostUsd = event.totalCostUsd;
+    }
+    return compact;
 }
 async function runSequentially(tasks) {
     const results = [];

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

@@ -0,0 +1,64 @@
+import type { 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 { SessionController } from './session-controller.js';
+import type { GitOperations } from './git-operations.js';
+import type { ContextTracker } from './context-tracker.js';
+export type PersistentManagerProgressHandler = (run: PersistentRunRecord) => void | Promise<void>;
+export declare class PersistentManager {
+    private readonly sessionController;
+    private readonly gitOps;
+    private readonly stateStore;
+    private readonly contextTracker;
+    constructor(sessionController: SessionController, gitOps: GitOperations, stateStore: FileRunStateStore, contextTracker: ContextTracker);
+    /**
+     * Send a message to the persistent Claude Code session.
+     * Creates a new session if none exists.
+     */
+    sendMessage(cwd: string, message: string, options?: {
+        model?: string;
+    }, onEvent?: ClaudeSessionEventHandler): Promise<{
+        sessionId: string | undefined;
+        finalText: string;
+        turns?: number;
+        totalCostUsd?: number;
+        context: SessionContextSnapshot;
+    }>;
+    /**
+     * Get the current git diff.
+     */
+    gitDiff(): Promise<GitDiffResult>;
+    /**
+     * Commit all current changes.
+     */
+    gitCommit(message: string): Promise<GitOperationResult>;
+    /**
+     * 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(cwd: string): Promise<string | null>;
+    /**
+     * Compact the current session to free context.
+     */
+    compactSession(cwd: string, onEvent?: ClaudeSessionEventHandler): Promise<ClaudeSessionRunResult>;
+    /**
+     * 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>;
+    /**
+     * Try to restore session state from disk on startup.
+     */
+    tryRestore(cwd: string): Promise<boolean>;
+    listRuns(cwd: string): Promise<PersistentRunRecord[]>;
+    getRun(cwd: string, runId: string): Promise<PersistentRunRecord | null>;
+}

package/dist/manager/persistent-manager.js

@@ -0,0 +1,152 @@
+import { randomUUID } from 'node:crypto';
+export class PersistentManager {
+    sessionController;
+    gitOps;
+    stateStore;
+    contextTracker;
+    constructor(sessionController, gitOps, stateStore, contextTracker) {
+        this.sessionController = sessionController;
+        this.gitOps = gitOps;
+        this.stateStore = stateStore;
+        this.contextTracker = contextTracker;
+    }
+    /**
+     * 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(cwd, message, options, onEvent);
+        return {
+            sessionId: result.sessionId,
+            finalText: result.finalText,
+            turns: result.turns,
+            totalCostUsd: result.totalCostUsd,
+            context: this.sessionController.getContextSnapshot(),
+        };
+    }
+    /**
+     * Get the current git diff.
+     */
+    async gitDiff() {
+        return this.gitOps.diff();
+    }
+    /**
+     * Commit all current changes.
+     */
+    async gitCommit(message) {
+        return this.gitOps.commit(message);
+    }
+    /**
+     * Hard reset to discard all uncommitted changes.
+     */
+    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(cwd) {
+        return this.sessionController.clearSession(cwd);
+    }
+    /**
+     * Compact the current session to free context.
+     */
+    async compactSession(cwd, onEvent) {
+        return this.sessionController.compactSession(cwd, onEvent);
+    }
+    /**
+     * 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(cwd, 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 };
+        }
+    }
+    /**
+     * Try to restore session state from disk on startup.
+     */
+    async tryRestore(cwd) {
+        return this.sessionController.tryRestore(cwd);
+    }
+    listRuns(cwd) {
+        return this.stateStore.listRuns(cwd);
+    }
+    getRun(cwd, runId) {
+        return this.stateStore.getRun(cwd, runId);
+    }
+}