@co0ontty/wand 1.7.0 → 1.9.0

package/dist/config.js

@@ -16,6 +16,20 @@ export const defaultConfig = () => ({
     allowedCommandPrefixes: [],
     shortcutLogMaxBytes: 10 * 1024 * 1024,
     language: "",
+    uiPreferences: {
+        defaultPanelState: {
+            sessionsDrawerOpen: false,
+            filePanelOpen: false,
+            shortcutsExpanded: false,
+            claudeHistoryExpanded: true,
+            chatMessageExpanded: true,
+            structuredThinkingExpanded: true,
+            structuredToolGroupExpanded: false,
+            structuredInlineToolExpanded: false,
+            structuredTerminalExpanded: false,
+            structuredToolCardExpanded: false,
+        }
+    },
     commandPresets: [
         {
             label: "Claude",
@@ -101,8 +115,26 @@ function normalizeStructuredChatPersona(input) {
         return undefined;
     return { user, assistant };
 }
+function normalizeDefaultPanelState(input) {
+    if (!input || typeof input !== "object")
+        return undefined;
+    const state = input;
+    return {
+        sessionsDrawerOpen: typeof state.sessionsDrawerOpen === "boolean" ? state.sessionsDrawerOpen : undefined,
+        filePanelOpen: typeof state.filePanelOpen === "boolean" ? state.filePanelOpen : undefined,
+        shortcutsExpanded: typeof state.shortcutsExpanded === "boolean" ? state.shortcutsExpanded : undefined,
+        claudeHistoryExpanded: typeof state.claudeHistoryExpanded === "boolean" ? state.claudeHistoryExpanded : undefined,
+        chatMessageExpanded: typeof state.chatMessageExpanded === "boolean" ? state.chatMessageExpanded : undefined,
+        structuredThinkingExpanded: typeof state.structuredThinkingExpanded === "boolean" ? state.structuredThinkingExpanded : undefined,
+        structuredToolGroupExpanded: typeof state.structuredToolGroupExpanded === "boolean" ? state.structuredToolGroupExpanded : undefined,
+        structuredInlineToolExpanded: typeof state.structuredInlineToolExpanded === "boolean" ? state.structuredInlineToolExpanded : undefined,
+        structuredTerminalExpanded: typeof state.structuredTerminalExpanded === "boolean" ? state.structuredTerminalExpanded : undefined,
+        structuredToolCardExpanded: typeof state.structuredToolCardExpanded === "boolean" ? state.structuredToolCardExpanded : undefined,
+    };
+}
 function mergeWithDefaults(input) {
     const defaults = defaultConfig();
+    const normalizedPanelState = normalizeDefaultPanelState(input.uiPreferences?.defaultPanelState);
     return {
         ...defaults,
         ...input,
@@ -132,6 +164,14 @@ function mergeWithDefaults(input) {
             : defaults.commandPresets,
         structuredChatPersona: normalizeStructuredChatPersona(input.structuredChatPersona),
         language: typeof input.language === "string" ? input.language.trim() : defaults.language,
+        uiPreferences: {
+            ...defaults.uiPreferences,
+            ...(input.uiPreferences || {}),
+            defaultPanelState: {
+                ...defaults.uiPreferences?.defaultPanelState,
+                ...(normalizedPanelState || {}),
+            }
+        },
     };
 }
 export function isExecutionMode(value) {

package/dist/git-worktree.d.ts

@@ -1,4 +1,4 @@
-import { SessionSnapshot } from "./types.js";
+import { SessionSnapshot, WorktreeMergeCheckResult, WorktreeMergeResult } from "./types.js";
 interface WorktreeSetupOptions {
     cwd: string;
     sessionId: string;
@@ -8,5 +8,21 @@ interface WorktreeSetupResult {
     worktreeEnabled: boolean;
     worktree: NonNullable<SessionSnapshot["worktree"]>;
 }
+interface WorktreeOperationOptions {
+    worktree: NonNullable<SessionSnapshot["worktree"]>;
+}
+interface WorktreeMergeOptions extends WorktreeOperationOptions {
+    targetBranch?: string;
+}
+export declare class WorktreeMergeError extends Error {
+    readonly code: string;
+    readonly result?: Partial<WorktreeMergeResult> | undefined;
+    constructor(code: string, message: string, result?: Partial<WorktreeMergeResult> | undefined);
+}
+export declare function getDefaultBaseBranch(repoRoot: string): string;
+export declare function getWorktreeMergeErrorCode(error: unknown): string | undefined;
+export declare function checkSessionWorktreeMergeability(options: WorktreeMergeOptions): WorktreeMergeCheckResult;
+export declare function cleanupSessionWorktree(options: WorktreeOperationOptions): boolean;
+export declare function mergeSessionWorktree(options: WorktreeMergeOptions): WorktreeMergeResult;
 export declare function prepareSessionWorktree(options: WorktreeSetupOptions): WorktreeSetupResult;
 export {};

package/dist/git-worktree.js

@@ -1,6 +1,24 @@
 import { existsSync, mkdirSync } from "node:fs";
 import { execFileSync } from "node:child_process";
 import path from "node:path";
+const WORKTREE_MERGE_ERROR_CODES = {
+    MISSING: "WORKTREE_MISSING",
+    DIRTY: "WORKTREE_DIRTY",
+    TARGET_MISSING: "TARGET_BRANCH_MISSING",
+    NOTHING_TO_MERGE: "NOTHING_TO_MERGE",
+    CONFLICT: "WORKTREE_MERGE_CONFLICT",
+    CLEANUP_FAILED: "WORKTREE_CLEANUP_FAILED",
+};
+export class WorktreeMergeError extends Error {
+    code;
+    result;
+    constructor(code, message, result) {
+        super(message);
+        this.code = code;
+        this.result = result;
+        this.name = "WorktreeMergeError";
+    }
+}
 function runGit(args, cwd) {
     return execFileSync("git", args, {
         cwd,
@@ -19,6 +37,232 @@ function getCurrentBranch(repoRoot) {
     const branch = runGit(["branch", "--show-current"], repoRoot);
     return branch || "master";
 }
+function isGitCommandError(error) {
+    return error instanceof Error;
+}
+function getGitCommandMessage(error) {
+    if (isGitCommandError(error)) {
+        return error.stderr?.trim() || error.stdout?.trim() || error.message;
+    }
+    return String(error);
+}
+function refExists(repoRoot, ref) {
+    try {
+        runGit(["rev-parse", "--verify", ref], repoRoot);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function getRepoRootFromWorktree(worktreePath) {
+    const repoRoot = runGit(["rev-parse", "--show-toplevel"], worktreePath);
+    if (!repoRoot || !existsSync(repoRoot)) {
+        throw new WorktreeMergeError(WORKTREE_MERGE_ERROR_CODES.MISSING, "Worktree 仓库根目录不存在。", {
+            cleanupDone: false,
+            conflict: false,
+        });
+    }
+    return repoRoot;
+}
+function ensureWorktreePath(worktree) {
+    const worktreePath = path.resolve(worktree.path);
+    if (!existsSync(worktreePath)) {
+        throw new WorktreeMergeError(WORKTREE_MERGE_ERROR_CODES.MISSING, "Worktree 目录不存在，可能已被手动删除。", {
+            cleanupDone: false,
+            conflict: false,
+        });
+    }
+    return worktreePath;
+}
+function getMainRepoRoot(repoRoot) {
+    const commonDir = runGit(["rev-parse", "--git-common-dir"], repoRoot);
+    if (commonDir) {
+        const maybeRoot = path.resolve(repoRoot, commonDir, "..");
+        if (existsSync(maybeRoot)) {
+            return maybeRoot;
+        }
+    }
+    return repoRoot;
+}
+export function getDefaultBaseBranch(repoRoot) {
+    try {
+        const symbolicRef = runGit(["symbolic-ref", "refs/remotes/origin/HEAD"], repoRoot);
+        const match = symbolicRef.match(/^refs\/remotes\/origin\/(.+)$/);
+        if (match && match[1]) {
+            return match[1];
+        }
+    }
+    catch {
+        // ignore and fallback below
+    }
+    const candidates = ["master", "main", getCurrentBranch(repoRoot)];
+    for (const candidate of candidates) {
+        if (candidate && refExists(repoRoot, candidate)) {
+            return candidate;
+        }
+    }
+    return "master";
+}
+function getMainRepoContext(options) {
+    const worktreePath = ensureWorktreePath(options.worktree);
+    const worktreeRepoRoot = getRepoRootFromWorktree(worktreePath);
+    const repoRoot = getMainRepoRoot(worktreeRepoRoot);
+    const sourceBranch = options.worktree.branch;
+    if (!refExists(repoRoot, sourceBranch)) {
+        throw new WorktreeMergeError(WORKTREE_MERGE_ERROR_CODES.MISSING, "Worktree 分支不存在，可能已被手动删除。", {
+            cleanupDone: false,
+            conflict: false,
+        });
+    }
+    const targetBranch = options.targetBranch?.trim() || getDefaultBaseBranch(repoRoot);
+    if (!refExists(repoRoot, targetBranch)) {
+        throw new WorktreeMergeError(WORKTREE_MERGE_ERROR_CODES.TARGET_MISSING, `目标分支不存在：${targetBranch}`, {
+            cleanupDone: false,
+            conflict: false,
+            targetBranch,
+        });
+    }
+    return { repoRoot, worktreePath, sourceBranch, targetBranch };
+}
+function hasUncommittedChanges(worktreePath) {
+    const worktreeRepoRoot = getRepoRootFromWorktree(worktreePath);
+    return runGit(["status", "--porcelain"], worktreeRepoRoot).length > 0;
+}
+function getAheadCount(repoRoot, targetBranch, sourceBranch) {
+    const count = runGit(["rev-list", "--count", `${targetBranch}..${sourceBranch}`], repoRoot);
+    return Number.parseInt(count || "0", 10) || 0;
+}
+function checkConflicts(repoRoot, targetBranch, sourceBranch) {
+    try {
+        runGit(["merge-tree", targetBranch, sourceBranch], repoRoot);
+        return false;
+    }
+    catch {
+        return true;
+    }
+}
+function ensureMergeableContext(options) {
+    const context = getMainRepoContext(options);
+    if (hasUncommittedChanges(context.worktreePath)) {
+        throw new WorktreeMergeError(WORKTREE_MERGE_ERROR_CODES.DIRTY, "Worktree 中仍有未提交改动，请先提交后再合并。", {
+            sourceBranch: context.sourceBranch,
+            targetBranch: context.targetBranch,
+            repoRoot: context.repoRoot,
+            cleanupDone: false,
+            conflict: false,
+        });
+    }
+    const aheadCount = getAheadCount(context.repoRoot, context.targetBranch, context.sourceBranch);
+    if (aheadCount <= 0) {
+        throw new WorktreeMergeError(WORKTREE_MERGE_ERROR_CODES.NOTHING_TO_MERGE, "当前 worktree 没有可合并到主分支的新提交。", {
+            sourceBranch: context.sourceBranch,
+            targetBranch: context.targetBranch,
+            repoRoot: context.repoRoot,
+            cleanupDone: false,
+            conflict: false,
+        });
+    }
+    return { ...context, aheadCount };
+}
+function buildCheckResult(context, aheadCount, hasDirtyChanges, hasConflicts) {
+    const ok = !hasDirtyChanges && aheadCount > 0 && !hasConflicts;
+    return {
+        ok,
+        sourceBranch: context.sourceBranch,
+        targetBranch: context.targetBranch,
+        worktreePath: context.worktreePath,
+        repoRoot: context.repoRoot,
+        hasUncommittedChanges: hasDirtyChanges,
+        aheadCount,
+        hasConflicts,
+        recommendedAction: hasConflicts ? "resolve-conflict" : aheadCount > 0 ? "merge" : "noop",
+        reason: hasDirtyChanges
+            ? "Worktree 中仍有未提交改动。"
+            : aheadCount <= 0
+                ? "当前 worktree 没有可合并的新提交。"
+                : hasConflicts
+                    ? "检测到潜在冲突，请先处理。"
+                    : undefined,
+    };
+}
+function getHeadCommit(repoRoot) {
+    return runGit(["rev-parse", "HEAD"], repoRoot);
+}
+function cleanupMergedWorktree(context) {
+    runGit(["worktree", "remove", context.worktreePath], context.repoRoot);
+    runGit(["branch", "-d", context.sourceBranch], context.repoRoot);
+    return true;
+}
+export function getWorktreeMergeErrorCode(error) {
+    return error instanceof WorktreeMergeError ? error.code : undefined;
+}
+export function checkSessionWorktreeMergeability(options) {
+    const context = getMainRepoContext(options);
+    const hasDirtyChanges = hasUncommittedChanges(context.worktreePath);
+    const aheadCount = getAheadCount(context.repoRoot, context.targetBranch, context.sourceBranch);
+    const hasConflicts = !hasDirtyChanges && aheadCount > 0
+        ? checkConflicts(context.repoRoot, context.targetBranch, context.sourceBranch)
+        : false;
+    return buildCheckResult(context, aheadCount, hasDirtyChanges, hasConflicts);
+}
+export function cleanupSessionWorktree(options) {
+    const context = getMainRepoContext({ worktree: options.worktree });
+    return cleanupMergedWorktree(context);
+}
+export function mergeSessionWorktree(options) {
+    const context = ensureMergeableContext(options);
+    const hasConflicts = checkConflicts(context.repoRoot, context.targetBranch, context.sourceBranch);
+    if (hasConflicts) {
+        throw new WorktreeMergeError(WORKTREE_MERGE_ERROR_CODES.CONFLICT, "合并检测到冲突，请先手动处理。", {
+            sourceBranch: context.sourceBranch,
+            targetBranch: context.targetBranch,
+            repoRoot: context.repoRoot,
+            cleanupDone: false,
+            conflict: true,
+        });
+    }
+    try {
+        runGit(["checkout", context.targetBranch], context.repoRoot);
+        runGit(["merge", "--no-ff", "--no-edit", context.sourceBranch], context.repoRoot);
+    }
+    catch (error) {
+        const message = getGitCommandMessage(error);
+        throw new WorktreeMergeError(WORKTREE_MERGE_ERROR_CODES.CONFLICT, message || "合并失败，可能存在冲突。", {
+            sourceBranch: context.sourceBranch,
+            targetBranch: context.targetBranch,
+            repoRoot: context.repoRoot,
+            cleanupDone: false,
+            conflict: true,
+        });
+    }
+    const mergedAt = new Date().toISOString();
+    const mergeCommit = getHeadCommit(context.repoRoot);
+    try {
+        cleanupMergedWorktree(context);
+        return {
+            ok: true,
+            sourceBranch: context.sourceBranch,
+            targetBranch: context.targetBranch,
+            repoRoot: context.repoRoot,
+            mergeCommit,
+            mergedAt,
+            cleanupDone: true,
+            conflict: false,
+        };
+    }
+    catch (error) {
+        throw new WorktreeMergeError(WORKTREE_MERGE_ERROR_CODES.CLEANUP_FAILED, getGitCommandMessage(error) || "已合并，但清理 worktree 失败。", {
+            sourceBranch: context.sourceBranch,
+            targetBranch: context.targetBranch,
+            repoRoot: context.repoRoot,
+            mergeCommit,
+            mergedAt,
+            cleanupDone: false,
+            conflict: false,
+        });
+    }
+}
 export function prepareSessionWorktree(options) {
     const resolvedCwd = path.resolve(options.cwd);
     const repoRoot = runGit(["rev-parse", "--show-toplevel"], resolvedCwd);

package/dist/server-session-routes.js

@@ -1,6 +1,7 @@
 import express from "express";
 import { parseMessages } from "./message-parser.js";
 import { SessionInputError } from "./process-manager.js";
+import { checkSessionWorktreeMergeability, cleanupSessionWorktree, getWorktreeMergeErrorCode, mergeSessionWorktree, WorktreeMergeError } from "./git-worktree.js";
 export function getErrorMessage(error, fallback) {
     return error instanceof Error ? error.message : fallback;
 }
@@ -70,6 +71,66 @@ function listAllSessions(processes, structured) {
     return [...structured.list(), ...processes.list()]
         .sort((a, b) => b.startedAt.localeCompare(a.startedAt));
 }
+function requireWorktreeSession(snapshot) {
+    if (!snapshot) {
+        throw new Error("未找到该会话。");
+    }
+    if (!snapshot.worktreeEnabled || !snapshot.worktree?.branch || !snapshot.worktree?.path) {
+        throw new Error("该会话未启用 worktree 模式。 ");
+    }
+    return snapshot;
+}
+function buildWorktreeMergeInfo(current, status, info) {
+    return {
+        ...(current.worktreeMergeInfo ?? null),
+        ...(info ?? null),
+        lastError: info?.lastError,
+        conflict: info?.conflict,
+    };
+}
+function saveWorktreeMergeState(storage, current, status, info) {
+    const mergedInfo = buildWorktreeMergeInfo(current, status, info);
+    const updated = {
+        ...current,
+        worktreeMergeStatus: status,
+        worktreeMergeInfo: mergedInfo,
+    };
+    storage.saveSessionMetadata(updated);
+    return updated;
+}
+function getWorktreeMergeResponseStatus(error) {
+    const code = getWorktreeMergeErrorCode(error);
+    if (!code) {
+        return 400;
+    }
+    if (code === "WORKTREE_MERGE_CONFLICT") {
+        return 409;
+    }
+    return 400;
+}
+function getWorktreeMergePayload(error, fallback) {
+    if (error instanceof WorktreeMergeError) {
+        return {
+            error: error.message,
+            errorCode: error.code,
+            result: error.result ?? null,
+        };
+    }
+    return {
+        error: getErrorMessage(error, fallback),
+        errorCode: getWorktreeMergeErrorCode(error) ?? null,
+        result: null,
+    };
+}
+function getLatestSessionSnapshot(processes, structured, storage, id) {
+    return getSessionById(processes, structured, id) ?? storage.getSession(id);
+}
+function canMergeSession(snapshot) {
+    return Boolean(snapshot.worktreeEnabled && snapshot.worktree?.branch && snapshot.worktree?.path);
+}
+function isMergeActionAllowed(snapshot) {
+    return snapshot.status !== "running";
+}
 export function registerSessionRoutes(app, processes, structured, storage, defaultMode) {
     app.get("/api/sessions", (_req, res) => {
         const all = listAllSessions(processes, structured);
@@ -117,6 +178,98 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
             res.status(400).json({ error: getErrorMessage(error, "无法发送结构化消息。") });
         }
     });
+    app.post("/api/sessions/:id/worktree/merge/check", (req, res) => {
+        try {
+            const current = requireWorktreeSession(getLatestSessionSnapshot(processes, structured, storage, req.params.id));
+            if (!isMergeActionAllowed(current)) {
+                res.status(409).json({ error: "会话仍在运行，请结束后再合并。", errorCode: "SESSION_STILL_RUNNING" });
+                return;
+            }
+            const checking = saveWorktreeMergeState(storage, current, "checking", {
+                ...(current.worktreeMergeInfo ?? null),
+                targetBranch: current.worktreeMergeInfo?.targetBranch,
+                lastError: undefined,
+                conflict: false,
+            });
+            const result = checkSessionWorktreeMergeability({
+                worktree: checking.worktree,
+                targetBranch: current.worktreeMergeInfo?.targetBranch,
+            });
+            const nextStatus = result.ok ? "ready" : "failed";
+            const updated = saveWorktreeMergeState(storage, checking, nextStatus, {
+                targetBranch: result.targetBranch,
+                conflict: result.hasConflicts,
+                lastError: result.ok ? undefined : result.reason,
+            });
+            res.json({ session: updated, result });
+        }
+        catch (error) {
+            res.status(getWorktreeMergeResponseStatus(error)).json(getWorktreeMergePayload(error, "无法检查 worktree 合并状态。"));
+        }
+    });
+    app.post("/api/sessions/:id/worktree/merge", express.json(), (req, res) => {
+        try {
+            const current = requireWorktreeSession(getLatestSessionSnapshot(processes, structured, storage, req.params.id));
+            if (!isMergeActionAllowed(current)) {
+                res.status(409).json({ error: "会话仍在运行，请结束后再合并。", errorCode: "SESSION_STILL_RUNNING" });
+                return;
+            }
+            const merging = saveWorktreeMergeState(storage, current, "merging", {
+                ...(current.worktreeMergeInfo ?? null),
+                lastError: undefined,
+                conflict: false,
+            });
+            const result = mergeSessionWorktree({
+                worktree: merging.worktree,
+                targetBranch: current.worktreeMergeInfo?.targetBranch,
+            });
+            const updated = saveWorktreeMergeState(storage, merging, "merged", {
+                targetBranch: result.targetBranch,
+                mergedAt: result.mergedAt,
+                mergeCommit: result.mergeCommit,
+                cleanupDone: result.cleanupDone,
+                lastError: undefined,
+                conflict: false,
+            });
+            res.json({ session: updated, result });
+        }
+        catch (error) {
+            const current = getLatestSessionSnapshot(processes, structured, storage, req.params.id);
+            if (current && canMergeSession(current)) {
+                const payload = getWorktreeMergePayload(error, "无法合并 worktree。");
+                saveWorktreeMergeState(storage, current, "failed", {
+                    ...(current.worktreeMergeInfo ?? null),
+                    targetBranch: payload.result?.targetBranch ?? current.worktreeMergeInfo?.targetBranch,
+                    mergedAt: payload.result?.mergedAt,
+                    mergeCommit: payload.result?.mergeCommit,
+                    cleanupDone: payload.result?.cleanupDone,
+                    lastError: payload.error,
+                    conflict: payload.result?.conflict === true,
+                });
+            }
+            res.status(getWorktreeMergeResponseStatus(error)).json(getWorktreeMergePayload(error, "无法合并 worktree。"));
+        }
+    });
+    app.post("/api/sessions/:id/worktree/cleanup", (req, res) => {
+        try {
+            const current = requireWorktreeSession(getLatestSessionSnapshot(processes, structured, storage, req.params.id));
+            if (current.worktreeMergeStatus !== "merged" || current.worktreeMergeInfo?.cleanupDone !== false) {
+                res.status(400).json({ error: "当前 worktree 无需补偿清理。", errorCode: "WORKTREE_CLEANUP_NOT_NEEDED" });
+                return;
+            }
+            cleanupSessionWorktree({ worktree: current.worktree });
+            const updated = saveWorktreeMergeState(storage, current, "merged", {
+                ...(current.worktreeMergeInfo ?? null),
+                cleanupDone: true,
+                lastError: undefined,
+                conflict: false,
+            });
+            res.json({ session: updated, ok: true });
+        }
+        catch (error) {
+            res.status(getWorktreeMergeResponseStatus(error)).json(getWorktreeMergePayload(error, "无法清理 worktree。"));
+        }
+    });
     app.post("/api/sessions/batch-delete", express.json(), (req, res) => {
         const sessionIds = Array.isArray(req.body?.sessionIds)
             ? req.body.sessionIds.filter((value) => typeof value === "string" && value.trim().length > 0)

package/dist/server.js

@@ -519,6 +519,40 @@ export async function startServer(config, configPath) {
                 changed = true;
             }
         }
+        if (body.uiPreferences && typeof body.uiPreferences === "object") {
+            const defaultPanelStateInput = body.uiPreferences.defaultPanelState;
+            if (defaultPanelStateInput && typeof defaultPanelStateInput === "object") {
+                const nextDefaultPanelState = {
+                    ...config.uiPreferences?.defaultPanelState,
+                };
+                let panelChanged = false;
+                const panelFields = [
+                    "sessionsDrawerOpen",
+                    "filePanelOpen",
+                    "shortcutsExpanded",
+                    "claudeHistoryExpanded",
+                    "chatMessageExpanded",
+                    "structuredThinkingExpanded",
+                    "structuredToolGroupExpanded",
+                    "structuredInlineToolExpanded",
+                    "structuredTerminalExpanded",
+                    "structuredToolCardExpanded"
+                ];
+                for (const field of panelFields) {
+                    if (field in defaultPanelStateInput && typeof defaultPanelStateInput[field] === "boolean") {
+                        nextDefaultPanelState[field] = defaultPanelStateInput[field];
+                        panelChanged = true;
+                    }
+                }
+                if (panelChanged) {
+                    config.uiPreferences = {
+                        ...config.uiPreferences,
+                        defaultPanelState: nextDefaultPanelState,
+                    };
+                    changed = true;
+                }
+            }
+        }
         if (!changed) {
             res.status(400).json({ error: "没有可更新的配置字段。" });
             return;

package/dist/storage.d.ts

@@ -37,5 +37,6 @@ export declare class WandStorage {
     getLatestSessionByClaudeSessionId(claudeSessionId: string): SessionSnapshot | null;
     loadSessions(): SessionSnapshot[];
     private mapSessionRow;
+    updateSessionWorktreeMergeState(id: string, status: SessionSnapshot["worktreeMergeStatus"], info: SessionSnapshot["worktreeMergeInfo"]): SessionSnapshot | null;
     deleteSession(id: string): void;
 }