@co0ontty/wand 4.26.1 → 4.26.2-beta.gff48fb6

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
-  "commit": "22e10733b713c7daee366fbdff3abdf4722ca941",
-  "builtAt": "2026-07-26T11:24:52.326Z",
-  "version": "4.26.1",
-  "channel": "stable"
+  "commit": "ff48fb6d343b7941766c08633bc33ac7c772a554",
+  "builtAt": "2026-07-26T12:33:59.190Z",
+  "version": "4.26.2-beta.gff48fb6",
+  "channel": "beta"
 }

package/dist/config.d.ts

@@ -56,4 +56,3 @@ export declare function getProviderDefaultModels(config: Pick<WandConfig, "defau
     qoder: string;
 };
 export declare function getDefaultModelForProvider(config: Pick<WandConfig, "defaultModel" | "defaultCodexModel" | "defaultOpenCodeModel" | "defaultGrokModel" | "defaultQoderModel">, provider: SessionProvider | undefined): string;
-export declare function normalizeMode(input: string | undefined, fallback: ExecutionMode): ExecutionMode;

package/dist/config.js

@@ -691,9 +691,6 @@ export function getDefaultModelForProvider(config, provider) {
         return defaults.qoder;
     return defaults.claude;
 }
-export function normalizeMode(input, fallback) {
-    return isExecutionMode(input) ? input : fallback;
-}
 function normalizePresetCommand(command) {
     const trimmed = command.trim();
     if (trimmed === "cloud-code" || trimmed === "cloudcode" || trimmed === "claude code") {

package/dist/git-quick-commit.d.ts

@@ -1,6 +1,5 @@
 import { GitStatusResult, PushResult, QuickCommitResult, SessionProvider, SessionSnapshot, TagHeadResult } from "./types.js";
 export type QuickCommitErrorCode = "CWD_MISSING" | "NO_CWD" | "NOT_A_GIT_REPO" | "NO_COMMIT" | "NOTHING_TO_COMMIT" | "NOTHING_TO_PUSH" | "EMPTY_MESSAGE" | "EMPTY_TAG" | "EMPTY_AI_MESSAGE" | "AI_FALLBACK_FAILED" | "INVALID_AI_TAG" | "TAG_EXISTS" | "GIT_ADD_FAILED" | "GIT_DIFF_FAILED" | "GIT_COMMIT_FAILED" | "GIT_TAG_FAILED" | "CLAUDE_CLI_MISSING" | "CLAUDE_CLI_FAILED" | "CLAUDE_TIMEOUT";
-export declare function getGitStatus(cwd: string): GitStatusResult;
 /** Non-blocking status implementation used by HTTP routes. */
 export declare function getGitStatusAsync(cwd: string): Promise<GitStatusResult>;
 interface QuickCommitOptions {

package/dist/git-quick-commit.js

@@ -3,7 +3,7 @@ import { spawn } from "node:child_process";
 import { ClaudeRunError, runClaudePrint } from "./claude-sdk-runner.js";
 import { callSystemAiTextWithFallback } from "./system-ai.js";
 import { buildChildEnv } from "./env-utils.js";
-import { runGit as runGitBase, runGitAsync as runGitAsyncBase, runGitRaw as runGitRawBase, runGitRawAsync as runGitRawAsyncBase, getGitErrorMessage, } from "./git-utils.js";
+import { runGitAsync as runGitAsyncBase, runGitRawAsync as runGitRawAsyncBase, getGitErrorMessage, } from "./git-utils.js";
 import { thinkingEffortToClaudeCliEffort, thinkingEffortToCodexReasoningEffort, thinkingEffortToGrokEffort, thinkingEffortToOpenCodeVariant, thinkingEffortToQoderEffort, } from "./structured-provider-common.js";
 const GIT_TIMEOUT_MS = 1500;
 const GIT_PUSH_TIMEOUT_MS = 30_000;
@@ -19,34 +19,12 @@ const DIRECT_API_PROFILE_TIMEOUT_MS = 20_000;
 const QUICK_COMMIT_CLI_TIMEOUT_MS = 120_000;
 const MAX_DIFF_FOR_AI = 100_000;
 const GIT_MAX_BUFFER = 16 * 1024 * 1024;
-function runGit(args, cwd, timeoutMs = GIT_TIMEOUT_MS) {
-    return runGitBase(args, cwd, { timeout: timeoutMs, maxBuffer: GIT_MAX_BUFFER });
-}
-function runGitAllowEmpty(args, cwd, timeoutMs = GIT_TIMEOUT_MS) {
-    return runGitRawBase(args, cwd, { timeout: timeoutMs, maxBuffer: GIT_MAX_BUFFER });
-}
 function runGitAsync(args, cwd, timeoutMs = GIT_TIMEOUT_MS) {
     return runGitAsyncBase(args, cwd, { timeout: timeoutMs, maxBuffer: GIT_MAX_BUFFER });
 }
 function runGitAllowEmptyAsync(args, cwd, timeoutMs = GIT_TIMEOUT_MS) {
     return runGitRawAsyncBase(args, cwd, { timeout: timeoutMs, maxBuffer: GIT_MAX_BUFFER });
 }
-/** Throws `QuickCommitError` if `cwd` isn't an existing path inside a git work tree. */
-function assertGitWorkTree(cwd) {
-    if (!cwd || !existsSync(cwd)) {
-        throw new QuickCommitError("工作目录不存在。", "CWD_MISSING");
-    }
-    let isInside;
-    try {
-        isInside = runGit(["rev-parse", "--is-inside-work-tree"], cwd);
-    }
-    catch (error) {
-        throw new QuickCommitError(getGitErrorMessage(error), "NOT_A_GIT_REPO");
-    }
-    if (isInside !== "true") {
-        throw new QuickCommitError("当前目录不在 git 仓库内。", "NOT_A_GIT_REPO");
-    }
-}
 async function assertGitWorkTreeAsync(cwd) {
     if (!cwd || !existsSync(cwd))
         throw new QuickCommitError("工作目录不存在。", "CWD_MISSING");
@@ -61,22 +39,6 @@ async function assertGitWorkTreeAsync(cwd) {
         throw new QuickCommitError(getGitErrorMessage(error), "NOT_A_GIT_REPO");
     }
 }
-/**
- * Resolve the remote to push to. Prefers `branch.<name>.remote` config for the
- * current branch, falls back to `origin`. Never throws.
- */
-function resolvePushRemote(cwd) {
-    try {
-        const branch = runGit(["branch", "--show-current"], cwd);
-        if (branch) {
-            return runGit(["config", "--get", `branch.${branch}.remote`], cwd) || "origin";
-        }
-    }
-    catch {
-        // ignore — fall through to default
-    }
-    return "origin";
-}
 async function resolvePushRemoteAsync(cwd) {
     try {
         const branch = await runGitAsync(["branch", "--show-current"], cwd);
@@ -195,150 +157,6 @@ function parsePorcelainV2(raw) {
     }
     return out;
 }
-/**
- * 仓库是否声明了 submodule（读 repo 根的 .gitmodules）。不能只看 `git status`——一个
- * clean 的 submodule 不会出现在 status 里，但「是否提供 Submodule 选项」应基于声明而非当前改动。
- */
-function repoDeclaresSubmodule(repoRoot) {
-    if (!repoRoot)
-        return false;
-    const gitmodules = `${repoRoot}/.gitmodules`;
-    if (!existsSync(gitmodules))
-        return false;
-    try {
-        const out = runGitAllowEmpty(["config", "-f", gitmodules, "--get-regexp", "\\.path$"], repoRoot).trim();
-        return out.length > 0;
-    }
-    catch {
-        return false;
-    }
-}
-export function getGitStatus(cwd) {
-    if (!cwd || !existsSync(cwd)) {
-        return { isGit: false, error: "工作目录不存在。" };
-    }
-    let isInside;
-    try {
-        isInside = runGit(["rev-parse", "--is-inside-work-tree"], cwd);
-    }
-    catch {
-        return { isGit: false };
-    }
-    if (isInside !== "true") {
-        return { isGit: false };
-    }
-    let repoRoot;
-    try {
-        repoRoot = runGit(["rev-parse", "--show-toplevel"], cwd);
-    }
-    catch {
-        repoRoot = undefined;
-    }
-    let branch;
-    try {
-        branch = runGit(["branch", "--show-current"], cwd);
-    }
-    catch (error) {
-        return { isGit: true, repoRoot, error: getGitErrorMessage(error) };
-    }
-    if (!branch) {
-        try {
-            branch = `HEAD (${runGit(["rev-parse", "--short", "HEAD"], cwd)})`;
-        }
-        catch {
-            branch = "HEAD";
-        }
-    }
-    let head;
-    let initialCommit = false;
-    try {
-        head = runGit(["rev-parse", "HEAD"], cwd);
-    }
-    catch {
-        initialCommit = true;
-    }
-    let porcelain;
-    try {
-        porcelain = runGitAllowEmpty(["status", "--porcelain=v2", "--untracked-files=all"], cwd);
-    }
-    catch (error) {
-        return { isGit: true, branch, repoRoot, head, initialCommit, error: getGitErrorMessage(error) };
-    }
-    const allEntries = parsePorcelainV2(porcelain);
-    const files = allEntries.slice(0, MAX_FILE_ENTRIES);
-    let upstream;
-    let ahead;
-    let behind;
-    let lastCommit;
-    if (!initialCommit) {
-        try {
-            upstream = runGit(["rev-parse", "--abbrev-ref", "@{upstream}"], cwd) || undefined;
-        }
-        catch {
-            upstream = undefined;
-        }
-        if (upstream) {
-            try {
-                const counts = runGit(["rev-list", "--left-right", "--count", "@{upstream}...HEAD"], cwd);
-                const parts = counts.split(/\s+/).filter(Boolean);
-                if (parts.length === 2) {
-                    const b = Number.parseInt(parts[0], 10);
-                    const a = Number.parseInt(parts[1], 10);
-                    if (!Number.isNaN(a))
-                        ahead = a;
-                    if (!Number.isNaN(b))
-                        behind = b;
-                }
-            }
-            catch {
-                // ignore — counts stay undefined
-            }
-        }
-        try {
-            const raw = runGit(["log", "-1", "--pretty=format:%H%x09%h%x09%s"], cwd);
-            const parts = raw.split("\t");
-            if (parts.length >= 3) {
-                lastCommit = { hash: parts[0], shortHash: parts[1], subject: parts.slice(2).join("\t") };
-            }
-        }
-        catch {
-            // ignore
-        }
-    }
-    // NOTE: we intentionally do NOT probe the remote for unpushed tags here.
-    // `ls-remote` is a synchronous network call that can block the event loop
-    // for seconds. The "unpushed tag" UI chip is best-effort and a separate
-    // async endpoint should compute it on demand if reintroduced.
-    // Latest tag only. Next tag suggestions are intentionally AI-derived from the
-    // diff so releases do not silently follow a fixed patch-bump rule.
-    let latestTag;
-    if (!initialCommit) {
-        try {
-            latestTag = runGit(["describe", "--tags", "--abbrev=0"], cwd) || undefined;
-        }
-        catch {
-            latestTag = undefined;
-        }
-    }
-    return {
-        isGit: true,
-        branch,
-        modifiedCount: allEntries.length,
-        files,
-        head,
-        repoRoot,
-        initialCommit,
-        upstream,
-        ahead,
-        behind,
-        lastCommit,
-        latestTag,
-        // 供前端决定是否渲染 Submodule 球。status 全量条目（不受 files 的 200 条 slice 影响）
-        // 只能看到「有改动」的 submodule，clean submodule 不会出现在 status 里，所以再用
-        // .gitmodules 声明兜底——只要仓库声明了 submodule 就提供该选项。
-        hasSubmodule: allEntries.some((e) => e.isSubmodule) || repoDeclaresSubmodule(repoRoot),
-    };
-}
 async function repoDeclaresSubmoduleAsync(repoRoot) {
     if (!repoRoot)
         return false;

package/dist/git-worktree.d.ts

@@ -21,11 +21,7 @@ export declare class WorktreeMergeError extends Error {
     readonly result?: Partial<WorktreeMergeResult> | undefined;
     constructor(code: string, message: string, result?: Partial<WorktreeMergeResult> | undefined);
 }
-export declare function getDefaultBaseBranch(repoRoot: string, timeoutMs?: number): 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;
 /** Async HTTP-facing worktree check; commands remain deliberately serial. */
 export declare function checkSessionWorktreeMergeabilityAsync(options: WorktreeMergeOptions): Promise<WorktreeMergeCheckResult>;
 export declare function cleanupSessionWorktreeAsync(options: WorktreeOperationOptions): Promise<boolean>;

package/dist/git-worktree.js

@@ -39,25 +39,6 @@ function getCurrentBranch(repoRoot, timeoutMs = DEFAULT_WORKTREE_GIT_TIMEOUT_MS)
     const branch = runWorktreeGit(["branch", "--show-current"], repoRoot, timeoutMs);
     return branch || "master";
 }
-function refExists(repoRoot, ref, timeoutMs = DEFAULT_WORKTREE_GIT_TIMEOUT_MS) {
-    try {
-        runWorktreeGit(["rev-parse", "--verify", ref], repoRoot, timeoutMs);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function getRepoRootFromWorktree(worktreePath, timeoutMs = DEFAULT_WORKTREE_GIT_TIMEOUT_MS) {
-    const repoRoot = runWorktreeGit(["rev-parse", "--show-toplevel"], worktreePath, timeoutMs);
-    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)) {
@@ -68,97 +49,6 @@ function ensureWorktreePath(worktree) {
     }
     return worktreePath;
 }
-function getMainRepoRoot(repoRoot, timeoutMs = DEFAULT_WORKTREE_GIT_TIMEOUT_MS) {
-    const commonDir = runWorktreeGit(["rev-parse", "--git-common-dir"], repoRoot, timeoutMs);
-    if (commonDir) {
-        const maybeRoot = path.resolve(repoRoot, commonDir, "..");
-        if (existsSync(maybeRoot)) {
-            return maybeRoot;
-        }
-    }
-    return repoRoot;
-}
-export function getDefaultBaseBranch(repoRoot, timeoutMs = DEFAULT_WORKTREE_GIT_TIMEOUT_MS) {
-    try {
-        const symbolicRef = runWorktreeGit(["symbolic-ref", "refs/remotes/origin/HEAD"], repoRoot, timeoutMs);
-        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, timeoutMs)];
-    for (const candidate of candidates) {
-        if (candidate && refExists(repoRoot, candidate, timeoutMs)) {
-            return candidate;
-        }
-    }
-    return "master";
-}
-function getMainRepoContext(options) {
-    const gitTimeoutMs = resolveGitTimeout(options.gitTimeoutMs);
-    const worktreePath = ensureWorktreePath(options.worktree);
-    const worktreeRepoRoot = getRepoRootFromWorktree(worktreePath, gitTimeoutMs);
-    const repoRoot = getMainRepoRoot(worktreeRepoRoot, gitTimeoutMs);
-    const sourceBranch = options.worktree.branch;
-    if (!refExists(repoRoot, sourceBranch, gitTimeoutMs)) {
-        throw new WorktreeMergeError(WORKTREE_MERGE_ERROR_CODES.MISSING, "Worktree 分支不存在，可能已被手动删除。", {
-            cleanupDone: false,
-            conflict: false,
-        });
-    }
-    const targetBranch = options.targetBranch?.trim() || getDefaultBaseBranch(repoRoot, gitTimeoutMs);
-    if (!refExists(repoRoot, targetBranch, gitTimeoutMs)) {
-        throw new WorktreeMergeError(WORKTREE_MERGE_ERROR_CODES.TARGET_MISSING, `目标分支不存在：${targetBranch}`, {
-            cleanupDone: false,
-            conflict: false,
-            targetBranch,
-        });
-    }
-    return { repoRoot, worktreePath, sourceBranch, targetBranch, gitTimeoutMs };
-}
-function hasUncommittedChanges(worktreePath, timeoutMs = DEFAULT_WORKTREE_GIT_TIMEOUT_MS) {
-    const worktreeRepoRoot = getRepoRootFromWorktree(worktreePath, timeoutMs);
-    return runWorktreeGit(["status", "--porcelain"], worktreeRepoRoot, timeoutMs).length > 0;
-}
-function getAheadCount(repoRoot, targetBranch, sourceBranch, timeoutMs = DEFAULT_WORKTREE_GIT_TIMEOUT_MS) {
-    const count = runWorktreeGit(["rev-list", "--count", `${targetBranch}..${sourceBranch}`], repoRoot, timeoutMs);
-    return Number.parseInt(count || "0", 10) || 0;
-}
-function checkConflicts(repoRoot, targetBranch, sourceBranch, timeoutMs = DEFAULT_WORKTREE_GIT_TIMEOUT_MS) {
-    try {
-        runWorktreeGit(["merge-tree", targetBranch, sourceBranch], repoRoot, timeoutMs);
-        return false;
-    }
-    catch {
-        return true;
-    }
-}
-function ensureMergeableContext(options) {
-    const context = getMainRepoContext(options);
-    if (hasUncommittedChanges(context.worktreePath, context.gitTimeoutMs)) {
-        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, context.gitTimeoutMs);
-    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 {
@@ -180,201 +70,13 @@ function buildCheckResult(context, aheadCount, hasDirtyChanges, hasConflicts) {
                     : undefined,
     };
 }
-function getHeadCommit(repoRoot, timeoutMs = DEFAULT_WORKTREE_GIT_TIMEOUT_MS) {
-    return runWorktreeGit(["rev-parse", "HEAD"], repoRoot, timeoutMs);
-}
-function captureCheckoutState(context) {
-    let branch = null;
-    try {
-        branch = runWorktreeGit(["symbolic-ref", "--quiet", "--short", "HEAD"], context.repoRoot, context.gitTimeoutMs) || null;
-    }
-    catch {
-        // A detached HEAD is a valid state and must be restored as such.
-    }
-    return {
-        branch,
-        head: getHeadCommit(context.repoRoot, context.gitTimeoutMs),
-    };
-}
-function isMergeInProgress(repoRoot, timeoutMs) {
-    try {
-        runWorktreeGit(["rev-parse", "--quiet", "--verify", "MERGE_HEAD"], repoRoot, timeoutMs);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
 function describeRollbackError(label, error) {
     const detail = getGitErrorMessage(error);
     return detail ? `${label}：${detail}` : label;
 }
-function rollbackFailedMerge(context, originalState, targetHead) {
-    const errors = [];
-    // The merge itself may have used a deliberately short request timeout. Give
-    // the local, non-networked recovery commands enough time to complete.
-    const recoveryTimeoutMs = Math.max(context.gitTimeoutMs, 1_000);
-    const attempt = (label, action) => {
-        try {
-            action();
-        }
-        catch (error) {
-            errors.push(describeRollbackError(label, error));
-        }
-    };
-    if (isMergeInProgress(context.repoRoot, recoveryTimeoutMs)) {
-        attempt("git merge --abort 失败", () => {
-            runWorktreeGit(["merge", "--abort"], context.repoRoot, recoveryTimeoutMs);
-        });
-    }
-    // A timeout can happen after Git has created the merge commit (for example,
-    // in a long-running post-merge hook), in which case MERGE_HEAD is already
-    // gone. Reset the target branch explicitly before restoring the old checkout.
-    let currentBranch = null;
-    try {
-        currentBranch = runWorktreeGit(["symbolic-ref", "--quiet", "--short", "HEAD"], context.repoRoot, recoveryTimeoutMs) || null;
-    }
-    catch {
-        // Detached HEAD, or a transient repository error handled by validation.
-    }
-    if (currentBranch === context.targetBranch) {
-        attempt("恢复目标分支 HEAD 失败", () => {
-            const currentHead = getHeadCommit(context.repoRoot, recoveryTimeoutMs);
-            if (currentHead !== targetHead) {
-                runWorktreeGit(["reset", "--merge", targetHead], context.repoRoot, recoveryTimeoutMs);
-            }
-        });
-    }
-    if (originalState.branch) {
-        attempt("恢复原分支失败", () => {
-            const branch = runWorktreeGit(["symbolic-ref", "--quiet", "--short", "HEAD"], context.repoRoot, recoveryTimeoutMs);
-            if (branch !== originalState.branch) {
-                runWorktreeGit(["checkout", "--quiet", originalState.branch], context.repoRoot, recoveryTimeoutMs);
-            }
-        });
-        attempt("恢复原分支 HEAD 失败", () => {
-            const currentHead = getHeadCommit(context.repoRoot, recoveryTimeoutMs);
-            if (currentHead !== originalState.head) {
-                runWorktreeGit(["reset", "--merge", originalState.head], context.repoRoot, recoveryTimeoutMs);
-            }
-        });
-    }
-    else {
-        attempt("恢复 detached HEAD 失败", () => {
-            const branch = runWorktreeGit(["branch", "--show-current"], context.repoRoot, recoveryTimeoutMs);
-            const currentHead = getHeadCommit(context.repoRoot, recoveryTimeoutMs);
-            if (branch || currentHead !== originalState.head) {
-                runWorktreeGit(["checkout", "--quiet", "--detach", originalState.head], context.repoRoot, recoveryTimeoutMs);
-            }
-        });
-    }
-    if (isMergeInProgress(context.repoRoot, recoveryTimeoutMs)) {
-        errors.push("恢复后仓库仍存在未完成的 merge");
-    }
-    attempt("校验目标分支 HEAD 失败", () => {
-        const restoredTargetHead = runWorktreeGit(["rev-parse", context.targetBranch], context.repoRoot, recoveryTimeoutMs);
-        if (restoredTargetHead !== targetHead) {
-            throw new Error(`期望 ${targetHead}，实际 ${restoredTargetHead}`);
-        }
-    });
-    attempt("校验原 checkout 状态失败", () => {
-        const restored = captureCheckoutState({ ...context, gitTimeoutMs: recoveryTimeoutMs });
-        if (restored.branch !== originalState.branch || restored.head !== originalState.head) {
-            throw new Error(`期望 ${originalState.branch ?? "detached"}@${originalState.head}，` +
-                `实际 ${restored.branch ?? "detached"}@${restored.head}`);
-        }
-    });
-    return errors;
-}
-function cleanupMergedWorktree(context) {
-    runWorktreeGit(["worktree", "remove", context.worktreePath], context.repoRoot, context.gitTimeoutMs);
-    runWorktreeGit(["branch", "-d", context.sourceBranch], context.repoRoot, context.gitTimeoutMs);
-    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, context.gitTimeoutMs);
-    const aheadCount = getAheadCount(context.repoRoot, context.targetBranch, context.sourceBranch, context.gitTimeoutMs);
-    const hasConflicts = !hasDirtyChanges && aheadCount > 0
-        ? checkConflicts(context.repoRoot, context.targetBranch, context.sourceBranch, context.gitTimeoutMs)
-        : false;
-    return buildCheckResult(context, aheadCount, hasDirtyChanges, hasConflicts);
-}
-export function cleanupSessionWorktree(options) {
-    const context = getMainRepoContext(options);
-    return cleanupMergedWorktree(context);
-}
-export function mergeSessionWorktree(options) {
-    const context = ensureMergeableContext(options);
-    const hasConflicts = checkConflicts(context.repoRoot, context.targetBranch, context.sourceBranch, context.gitTimeoutMs);
-    if (hasConflicts) {
-        throw new WorktreeMergeError(WORKTREE_MERGE_ERROR_CODES.CONFLICT, "合并检测到冲突，请先手动处理。", {
-            sourceBranch: context.sourceBranch,
-            targetBranch: context.targetBranch,
-            repoRoot: context.repoRoot,
-            cleanupDone: false,
-            conflict: true,
-        });
-    }
-    const originalState = captureCheckoutState(context);
-    const targetHead = runWorktreeGit(["rev-parse", context.targetBranch], context.repoRoot, context.gitTimeoutMs);
-    if (isMergeInProgress(context.repoRoot, context.gitTimeoutMs)) {
-        throw new WorktreeMergeError(WORKTREE_MERGE_ERROR_CODES.CONFLICT, "主工作区已有未完成的 merge，请先处理后再合并 worktree。", {
-            sourceBranch: context.sourceBranch,
-            targetBranch: context.targetBranch,
-            repoRoot: context.repoRoot,
-            cleanupDone: false,
-            conflict: true,
-        });
-    }
-    try {
-        runWorktreeGit(["checkout", context.targetBranch], context.repoRoot, context.gitTimeoutMs);
-        runWorktreeGit(["merge", "--no-ff", "--no-edit", "--no-gpg-sign", context.sourceBranch], context.repoRoot, context.gitTimeoutMs);
-    }
-    catch (error) {
-        const message = getGitErrorMessage(error);
-        const rollbackErrors = rollbackFailedMerge(context, originalState, targetHead);
-        const rollbackMessage = rollbackErrors.length > 0
-            ? `\n自动恢复主工作区时仍有问题：${rollbackErrors.join("；")}`
-            : "\n主工作区已恢复到合并前状态。";
-        throw new WorktreeMergeError(WORKTREE_MERGE_ERROR_CODES.CONFLICT, `${message || "合并失败，可能存在冲突。"}${rollbackMessage}`, {
-            sourceBranch: context.sourceBranch,
-            targetBranch: context.targetBranch,
-            repoRoot: context.repoRoot,
-            cleanupDone: false,
-            conflict: true,
-        });
-    }
-    const mergedAt = new Date().toISOString();
-    const mergeCommit = getHeadCommit(context.repoRoot, context.gitTimeoutMs);
-    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, getGitErrorMessage(error) || "已合并，但清理 worktree 失败。", {
-            sourceBranch: context.sourceBranch,
-            targetBranch: context.targetBranch,
-            repoRoot: context.repoRoot,
-            mergeCommit,
-            mergedAt,
-            cleanupDone: false,
-            conflict: false,
-        });
-    }
-}
 function runWorktreeGitAsync(args, cwd, timeoutMs) {
     return runGitAsync(args, cwd, { timeout: timeoutMs });
 }

package/dist/models.d.ts

@@ -102,11 +102,6 @@ export declare class ModelCatalogService {
     refresh(request?: ModelCatalogRefreshRequest): Promise<ModelCatalogRefreshResult>;
     private performRefresh;
 }
-/**
- * Compatibility helper for callers that only need a synchronous fallback
- * catalog. It intentionally does not own or mutate process-global state.
- */
-export declare function getCachedModels(options?: ModelRefreshOptions): ModelCache;
 /**
  * Compatibility helper for direct callers and unit tests. Server code should
  * use `ModelCatalogService` so the result is persisted and diffed.

package/dist/models.js

@@ -767,14 +767,6 @@ export class ModelCatalogService {
         return { ...this.snapshot(), changed, checkedAt };
     }
 }
-/**
- * Compatibility helper for callers that only need a synchronous fallback
- * catalog. It intentionally does not own or mutate process-global state.
- */
-export function getCachedModels(options = {}) {
-    const persisted = loadPersistedModelCatalog(options.storage);
-    return cloneCache(persisted?.catalog ?? createInitialCache(options));
-}
 /**
  * Compatibility helper for direct callers and unit tests. Server code should
  * use `ModelCatalogService` so the result is persisted and diffed.

package/dist/resume-policy.d.ts

@@ -1,8 +1,6 @@
 import type { SessionProvider } from "./types.js";
 /** Claude session IDs and Codex thread IDs are UUID-shaped identifiers. */
 export declare function isProviderSessionId(value: unknown): value is string;
-export declare function getResumeCommandSessionId(command: string): string | null;
-export declare function getCodexResumeCommandSessionId(command: string): string | null;
 /**
  * Provider-native IDs are not uniformly UUIDs: OpenCode uses `ses_*` and
  * older Qoder releases also emitted `qs_*`. Keep the accepted alphabet shell

package/dist/resume-policy.js

@@ -1,21 +1,11 @@
 const UUID_PATTERN = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
 const PROVIDER_SESSION_ID_PATTERN = new RegExp(`^${UUID_PATTERN}$`, "i");
-const RESUME_COMMAND_ID_PATTERN = new RegExp(`(?:^|\\s)--resume\\s+(${UUID_PATTERN})(?:\\s|$)`, "i");
-const CODEX_RESUME_COMMAND_ID_PATTERN = new RegExp(`(?:^|\\s)resume\\s+(${UUID_PATTERN})(?:\\s|$)`, "i");
 const SAFE_PROVIDER_SESSION_ID_PATTERN = /^[a-z0-9][a-z0-9._:-]{0,199}$/i;
 const SAFE_PROVIDER_SESSION_ID_SOURCE = "([a-z0-9][a-z0-9._:-]{0,199})";
 /** Claude session IDs and Codex thread IDs are UUID-shaped identifiers. */
 export function isProviderSessionId(value) {
     return typeof value === "string" && PROVIDER_SESSION_ID_PATTERN.test(value);
 }
-export function getResumeCommandSessionId(command) {
-    const match = RESUME_COMMAND_ID_PATTERN.exec(command);
-    return match?.[1] ?? null;
-}
-export function getCodexResumeCommandSessionId(command) {
-    const match = CODEX_RESUME_COMMAND_ID_PATTERN.exec(command);
-    return match?.[1] ?? null;
-}
 /**
  * Provider-native IDs are not uniformly UUIDs: OpenCode uses `ses_*` and
  * older Qoder releases also emitted `qs_*`. Keep the accepted alphabet shell

package/dist/server-session-routes.d.ts

@@ -59,5 +59,5 @@ export declare function buildSessionListPage(sessions: SessionSnapshot[], claude
  */
 export declare function markManagedProviderHistory<T extends ProviderHistorySession>(history: T[], sessions: SessionSnapshot[], provider: "claude" | "codex" | "opencode" | "qoder"): T[];
 export declare function registerSessionRoutes(app: Express, processes: ProcessManager, structured: StructuredSessionManager, storage: WandStorage, defaultMode: ExecutionMode, config: WandConfig, sessions: SessionRegistry, onSessionCreated?: (cwd: string | undefined | null) => void): void;
-export declare function registerClaudeHistoryRoutes(app: Express, processes: ProcessManager, structured: StructuredSessionManager, storage: WandStorage, sessionRegistry: SessionRegistry): void;
+export declare function registerClaudeHistoryRoutes(app: Express, processes: ProcessManager, _structured: StructuredSessionManager, storage: WandStorage, sessionRegistry: SessionRegistry): void;
 export {};

package/dist/server-session-routes.js

@@ -1332,7 +1332,7 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
         }
     });
 }
-export function registerClaudeHistoryRoutes(app, processes, structured, storage, sessionRegistry) {
+export function registerClaudeHistoryRoutes(app, processes, _structured, storage, sessionRegistry) {
     app.get("/api/claude-history", (_req, res) => {
         try {
             const history = markManagedProviderHistory(processes.listClaudeHistorySessions(), sessionRegistry.listSlim(), "claude");