@co0ontty/wand 1.25.5 → 1.29.0

package/dist/config.js

@@ -41,6 +41,7 @@ export const defaultConfig = () => ({
     shortcutLogMaxBytes: 10 * 1024 * 1024,
     language: "",
     android: defaultAndroidApkConfig(),
+    macos: defaultMacosDmgConfig(),
     cardDefaults: defaultCardExpandDefaults(),
     defaultModel: "",
     structuredRunner: "cli",
@@ -301,6 +302,28 @@ function normalizeAndroidApkConfig(input) {
             : defaults.currentApkFile,
     };
 }
+function defaultMacosDmgConfig() {
+    return {
+        enabled: false,
+        dmgDir: "macos",
+        currentDmgFile: "",
+    };
+}
+function normalizeMacosDmgConfig(input) {
+    if (!input || typeof input !== "object")
+        return undefined;
+    const defaults = defaultMacosDmgConfig();
+    const macosInput = input;
+    return {
+        enabled: typeof macosInput.enabled === "boolean" ? macosInput.enabled : defaults.enabled,
+        dmgDir: typeof macosInput.dmgDir === "string" && macosInput.dmgDir.trim()
+            ? macosInput.dmgDir.trim()
+            : defaults.dmgDir,
+        currentDmgFile: typeof macosInput.currentDmgFile === "string"
+            ? macosInput.currentDmgFile.trim()
+            : defaults.currentDmgFile,
+    };
+}
 function normalizeStructuredChatPersona(input) {
     if (!input || typeof input !== "object")
         return undefined;
@@ -358,6 +381,7 @@ function mergeWithDefaults(input) {
             ? input.appSecret
             : crypto.randomBytes(32).toString("hex"),
         android: normalizeAndroidApkConfig(input.android) ?? defaults.android,
+        macos: normalizeMacosDmgConfig(input.macos) ?? defaults.macos,
         cardDefaults: normalizeCardDefaults(input.cardDefaults),
         defaultModel: typeof input.defaultModel === "string" ? input.defaultModel.trim() : defaults.defaultModel,
         structuredRunner: (input.structuredRunner === "sdk" || input.structuredRunner === "cli") ? input.structuredRunner : defaults.structuredRunner,

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

@@ -1,4 +1,5 @@
-import { GitStatusResult, QuickCommitResult } from "./types.js";
+import { GitStatusResult, PushResult, QuickCommitResult, 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" | "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;
 interface QuickCommitOptions {
     cwd: string;
@@ -11,8 +12,8 @@ interface QuickCommitOptions {
     push?: boolean;
 }
 export declare class QuickCommitError extends Error {
-    readonly code: string;
-    constructor(message: string, code: string);
+    readonly code: QuickCommitErrorCode;
+    constructor(message: string, code: QuickCommitErrorCode);
 }
 export interface GenerateCommitMessageResult {
     message: string;
@@ -20,5 +21,21 @@ export interface GenerateCommitMessageResult {
     suggestedTag?: string;
 }
 export declare function generateCommitMessageOnly(cwd: string, language: string): Promise<GenerateCommitMessageResult>;
+interface TagHeadOptions {
+    cwd: string;
+    language: string;
+    /** Explicit tag name. If empty and `autoTag` is true, ask Claude to generate one. */
+    tag?: string;
+    autoTag?: boolean;
+    /** Push only this tag to its upstream remote after creating it. */
+    push?: boolean;
+}
+export declare function runTagHead(opts: TagHeadOptions): Promise<TagHeadResult>;
+interface PushOptions {
+    cwd: string;
+    pushCommits?: boolean;
+    pushTags?: boolean;
+}
+export declare function runPush(opts: PushOptions): Promise<PushResult>;
 export declare function runQuickCommit(opts: QuickCommitOptions): Promise<QuickCommitResult>;
 export {};

package/dist/git-quick-commit.js

@@ -31,6 +31,38 @@ function getGitErrorMessage(error) {
         return e.message;
     return String(error);
 }
+/** 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");
+    }
+}
+/**
+ * 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";
+}
 function unquotePath(raw) {
     if (raw.startsWith("\"") && raw.endsWith("\"")) {
         return raw.slice(1, -1).replace(/\\"/g, "\"").replace(/\\\\/g, "\\");
@@ -141,6 +173,49 @@ export function getGitStatus(cwd) {
     }
     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.
     return {
         isGit: true,
         branch,
@@ -149,6 +224,10 @@ export function getGitStatus(cwd) {
         head,
         repoRoot,
         initialCommit,
+        upstream,
+        ahead,
+        behind,
+        lastCommit,
     };
 }
 export class QuickCommitError extends Error {
@@ -356,30 +435,197 @@ ${diff}`;
     }
     return suggested;
 }
-// ── Direct git operations ──
-export async function runQuickCommit(opts) {
-    const { cwd, language, autoMessage, customMessage, tag, autoTag, push } = opts;
-    if (!cwd || !existsSync(cwd)) {
-        throw new QuickCommitError("工作目录不存在。", "CWD_MISSING");
+/**
+ * Push current branch (with upstream auto-setup) and/or tags.
+ * Errors are returned via `error` so callers can present partial-success states.
+ */
+function doPush(opts) {
+    const { cwd, pushCommits, pushTags } = opts;
+    let pushedCommits = false;
+    let pushedTags = false;
+    let hasUpstream = false;
+    try {
+        runGit(["rev-parse", "--abbrev-ref", "@{upstream}"], cwd);
+        hasUpstream = true;
     }
-    let isInside;
+    catch {
+        hasUpstream = false;
+    }
+    const pushRemote = resolvePushRemote(cwd);
     try {
-        isInside = runGit(["rev-parse", "--is-inside-work-tree"], cwd);
+        if (pushCommits) {
+            if (hasUpstream) {
+                runGit(["push", "--recurse-submodules=on-demand"], cwd, GIT_PUSH_TIMEOUT_MS);
+            }
+            else {
+                runGit(["push", "-u", "--recurse-submodules=on-demand", pushRemote, "HEAD"], cwd, GIT_PUSH_TIMEOUT_MS);
+            }
+            pushedCommits = true;
+        }
+        if (pushTags) {
+            if (Array.isArray(pushTags)) {
+                for (const name of pushTags) {
+                    runGit(["push", pushRemote, `refs/tags/${name}`], cwd, GIT_PUSH_TIMEOUT_MS);
+                }
+            }
+            else {
+                runGit(["push", pushRemote, "--tags"], cwd, GIT_PUSH_TIMEOUT_MS);
+            }
+            pushedTags = true;
+        }
+        return { pushedCommits, pushedTags };
     }
     catch (error) {
-        throw new QuickCommitError(getGitErrorMessage(error), "NOT_A_GIT_REPO");
+        return { pushedCommits, pushedTags, error: getGitErrorMessage(error) };
     }
-    if (isInside !== "true") {
-        throw new QuickCommitError("当前目录不在 git 仓库内。", "NOT_A_GIT_REPO");
+}
+export async function runTagHead(opts) {
+    const { cwd, language, tag, autoTag, push } = opts;
+    assertGitWorkTree(cwd);
+    let headHash;
+    try {
+        headHash = runGit(["rev-parse", "HEAD"], cwd);
+    }
+    catch {
+        throw new QuickCommitError("仓库还没有任何 commit，无法打 tag。", "NO_COMMIT");
+    }
+    let tagName = (tag || "").trim();
+    if (!tagName && autoTag) {
+        let headSubject = "";
+        try {
+            headSubject = runGit(["log", "-1", "--pretty=format:%s"], cwd);
+        }
+        catch {
+            headSubject = "";
+        }
+        tagName = await generateTagAfterCommit(cwd, language, headSubject || "");
+    }
+    if (!tagName) {
+        throw new QuickCommitError("请填写 tag 名称，或开启 AI 生成。", "EMPTY_TAG");
+    }
+    // Refuse to overwrite an existing tag — surface a clear error code.
+    try {
+        runGit(["rev-parse", "--verify", `refs/tags/${tagName}`], cwd);
+        throw new QuickCommitError(`tag \`${tagName}\` 已存在。`, "TAG_EXISTS");
+    }
+    catch (error) {
+        if (error instanceof QuickCommitError)
+            throw error;
+        // not found — good, proceed
     }
-    // Step 1: stage all
+    try {
+        runGit(["tag", tagName], cwd);
+    }
+    catch (error) {
+        throw new QuickCommitError(`git tag 失败：${getGitErrorMessage(error)}`, "GIT_TAG_FAILED");
+    }
+    let pushed = false;
+    let pushError;
+    if (push) {
+        const outcome = doPush({ cwd, pushCommits: false, pushTags: [tagName] });
+        pushed = outcome.pushedTags;
+        pushError = outcome.error;
+    }
+    return {
+        ok: true,
+        tag: { name: tagName, commit: headHash.slice(0, 7) },
+        pushed,
+        pushError,
+    };
+}
+export async function runPush(opts) {
+    const { cwd, pushCommits = true, pushTags = false } = opts;
+    assertGitWorkTree(cwd);
+    if (!pushCommits && !pushTags) {
+        throw new QuickCommitError("没有要推送的内容。", "NOTHING_TO_PUSH");
+    }
+    const outcome = doPush({ cwd, pushCommits, pushTags });
+    return {
+        ok: !outcome.error,
+        pushedCommits: outcome.pushedCommits,
+        pushedTags: outcome.pushedTags,
+        error: outcome.error,
+    };
+}
+/**
+ * 在 commit 父仓库之前，先在每个内部 dirty / untracked 的 submodule 里
+ * 执行一次 `git add -A` + `git commit -m <msg>`，让父仓库的 add -A
+ * 能正确捕捉到新的 submodule 指针。纯指针变化（仅 commitChanged）的
+ * submodule 不会进入这条路径——那种情况父仓库 add 已经够了。
+ *
+ * 任一 submodule 提交失败都会被收集为非致命错误，不阻塞父仓库继续 commit；
+ * 调用方可以在结果里读到具体哪几个 submodule 失败。
+ */
+function commitDirtySubmodules(parentCwd, message) {
+    const commits = [];
+    const errors = [];
+    let porcelain;
+    try {
+        porcelain = runGitAllowEmpty(["status", "--porcelain=v2", "--untracked-files=all"], parentCwd);
+    }
+    catch {
+        return { commits, errors };
+    }
+    const entries = parsePorcelainV2(porcelain);
+    for (const entry of entries) {
+        if (!entry.isSubmodule)
+            continue;
+        const state = entry.submoduleState;
+        if (!state)
+            continue;
+        // 只有内部脏 / 未跟踪才需要进入子目录提交；纯指针变化父仓库自己就能 add。
+        if (!state.hasTrackedChanges && !state.hasUntracked)
+            continue;
+        const subCwd = `${parentCwd}/${entry.path}`;
+        if (!existsSync(subCwd)) {
+            errors.push(`submodule ${entry.path} 路径不存在`);
+            continue;
+        }
+        try {
+            runGit(["add", "-A"], subCwd, 5000);
+        }
+        catch (error) {
+            errors.push(`submodule ${entry.path} add 失败：${getGitErrorMessage(error)}`);
+            continue;
+        }
+        // 子仓 add 之后再判断是否真的有 staged 内容：极端情况下 .gitignore 把所有 dirty
+        // 文件都过滤掉了，会得到一个空 diff，此时跳过避免空 commit。
+        let staged;
+        try {
+            staged = runGitAllowEmpty(["diff", "--cached", "--name-only"], subCwd).trim();
+        }
+        catch {
+            staged = "";
+        }
+        if (!staged)
+            continue;
+        try {
+            runGit(["commit", "-m", message], subCwd, 10_000);
+        }
+        catch (error) {
+            errors.push(`submodule ${entry.path} commit 失败：${getGitErrorMessage(error)}`);
+            continue;
+        }
+        let hash = "";
+        try {
+            hash = runGit(["rev-parse", "--short", "HEAD"], subCwd);
+        }
+        catch { /* ignore */ }
+        commits.push({ path: entry.path, hash });
+    }
+    return { commits, errors };
+}
+export async function runQuickCommit(opts) {
+    const { cwd, language, autoMessage, customMessage, tag, autoTag, push } = opts;
+    assertGitWorkTree(cwd);
+    // 先 add 一次让我们能在 collectStagedDiff 看到完整改动（包含 submodule 指针），
+    // AI 生成 message 时也基于这个 staged diff。
     try {
         runGit(["add", "-A"], cwd, 5000);
     }
     catch (error) {
         throw new QuickCommitError(`git add 失败：${getGitErrorMessage(error)}`, "GIT_ADD_FAILED");
     }
-    // Step 2: check if anything to commit
     let stagedFiles;
     try {
         stagedFiles = runGitAllowEmpty(["diff", "--cached", "--name-only"], cwd).trim();
@@ -387,10 +633,18 @@ export async function runQuickCommit(opts) {
     catch (error) {
         throw new QuickCommitError(getGitErrorMessage(error), "GIT_DIFF_FAILED");
     }
-    if (!stagedFiles) {
+    // 父仓库本身可能没有 staged 文件，但 submodule 内部有 dirty / untracked——
+    // 此时也应该允许走 submodule 提交流程。
+    let parentHasStaged = stagedFiles.length > 0;
+    let submoduleHasDirty = false;
+    try {
+        const porcelain = runGitAllowEmpty(["status", "--porcelain=v2", "--untracked-files=all"], cwd);
+        submoduleHasDirty = parsePorcelainV2(porcelain).some((e) => e.isSubmodule && (e.submoduleState?.hasTrackedChanges || e.submoduleState?.hasUntracked));
+    }
+    catch { /* keep submoduleHasDirty=false */ }
+    if (!parentHasStaged && !submoduleHasDirty) {
         throw new QuickCommitError("没有任何改动可以提交。", "NOTHING_TO_COMMIT");
     }
-    // Step 3: get commit message
     let message;
     if (autoMessage) {
         message = await generateCommitMessage(cwd, language);
@@ -401,7 +655,32 @@ export async function runQuickCommit(opts) {
             throw new QuickCommitError("commit message 不能为空。", "EMPTY_MESSAGE");
         }
     }
-    // Step 4: commit
+    // 先提交 submodule 内部改动；父仓库随后再 add 一次，picks up 新的 submodule 指针。
+    const submoduleOutcome = commitDirtySubmodules(cwd, message);
+    if (submoduleOutcome.commits.length > 0) {
+        try {
+            runGit(["add", "-A"], cwd, 5000);
+        }
+        catch (error) {
+            throw new QuickCommitError(`父仓库 add submodule 指针失败：${getGitErrorMessage(error)}`, "GIT_ADD_FAILED");
+        }
+        // 重新评估父仓库是否有 staged 内容：如果 submodule 是新引入的或指针变了，
+        // 这里应当为真；如果完全没变就走 commit --allow-empty 路径不合适，直接报错。
+        try {
+            stagedFiles = runGitAllowEmpty(["diff", "--cached", "--name-only"], cwd).trim();
+            parentHasStaged = stagedFiles.length > 0;
+        }
+        catch { /* keep stale value */ }
+    }
+    if (!parentHasStaged) {
+        // submodule 都提交了但父仓库还是没有 staged —— 通常意味着 .gitmodules 没动
+        // 而 submodule 指针被 ignore（罕见配置）。这种情况返回成功，但用 SUBMODULE_ONLY
+        // 的语义；上层 UI 可以决定是否继续 push。这里保持向后兼容，沿用 commit 路径
+        // 但用 --allow-empty 会有副作用，干脆抛 NOTHING_TO_COMMIT。
+        throw new QuickCommitError(submoduleOutcome.commits.length > 0
+            ? `已提交 ${submoduleOutcome.commits.length} 个 submodule，但父仓库没有改动可提交。`
+            : "没有任何改动可以提交。", "NOTHING_TO_COMMIT");
+    }
     try {
         runGit(["commit", "-m", message], cwd, 10_000);
     }
@@ -415,10 +694,7 @@ export async function runQuickCommit(opts) {
     catch {
         commitHash = "";
     }
-    // Step 5: tag
-    // - explicit `tag` wins
-    // - if `tag` is empty and `autoTag` is on, ask Claude to generate one
-    // - otherwise no tag
+    // Tag: explicit `tag` wins; if empty + autoTag, ask Claude; otherwise skip.
     let tagName = (tag || "").trim();
     if (!tagName && autoTag) {
         tagName = await generateTagAfterCommit(cwd, language, message);
@@ -431,41 +707,17 @@ export async function runQuickCommit(opts) {
             throw new QuickCommitError(`git tag 失败：${getGitErrorMessage(error)}`, "GIT_TAG_FAILED");
         }
     }
-    // Step 6: push
     let pushed = false;
     let pushError;
     if (push) {
-        try {
-            let hasUpstream = false;
-            let pushRemote = "origin";
-            try {
-                runGit(["rev-parse", "--abbrev-ref", "@{upstream}"], cwd);
-                hasUpstream = true;
-                try {
-                    const currentBranch = runGit(["branch", "--show-current"], cwd);
-                    if (currentBranch) {
-                        pushRemote = runGit(["config", "--get", `branch.${currentBranch}.remote`], cwd) || "origin";
-                    }
-                }
-                catch {
-                    pushRemote = "origin";
-                }
-            }
-            catch {
-                hasUpstream = false;
-            }
-            if (hasUpstream) {
-                runGit(["push", "--recurse-submodules=on-demand"], cwd, GIT_PUSH_TIMEOUT_MS);
-            }
-            else {
-                runGit(["push", "-u", "--recurse-submodules=on-demand", pushRemote, "HEAD"], cwd, GIT_PUSH_TIMEOUT_MS);
-            }
-            runGit(["push", pushRemote, "--tags"], cwd, GIT_PUSH_TIMEOUT_MS);
-            pushed = true;
-        }
-        catch (error) {
-            pushError = getGitErrorMessage(error);
-        }
+        const outcome = doPush({
+            cwd,
+            pushCommits: true,
+            // Push only the freshly-created tag — avoids surprising users by pushing stale local tags.
+            pushTags: tagName ? [tagName] : false,
+        });
+        pushed = outcome.pushedCommits && (tagName ? outcome.pushedTags : true);
+        pushError = outcome.error;
     }
     return {
         ok: true,
@@ -473,5 +725,6 @@ export async function runQuickCommit(opts) {
         tag: tagName ? { name: tagName } : undefined,
         pushed,
         pushError,
+        submoduleCommits: submoduleOutcome.commits.length > 0 ? submoduleOutcome.commits : undefined,
     };
 }

package/dist/server-session-routes.js

@@ -1,7 +1,7 @@
 import express from "express";
 import { SessionInputError } from "./process-manager.js";
 import { checkSessionWorktreeMergeability, cleanupSessionWorktree, getWorktreeMergeErrorCode, mergeSessionWorktree, WorktreeMergeError } from "./git-worktree.js";
-import { getGitStatus, QuickCommitError, runQuickCommit, generateCommitMessageOnly } from "./git-quick-commit.js";
+import { getGitStatus, QuickCommitError, runQuickCommit, runTagHead, runPush, generateCommitMessageOnly, } from "./git-quick-commit.js";
 export function getErrorMessage(error, fallback) {
     return error instanceof Error ? error.message : fallback;
 }
@@ -388,6 +388,63 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
             res.status(400).json({ error: getErrorMessage(error, "生成 commit message 失败。") });
         }
     });
+    app.post("/api/sessions/:id/git/tag-head", express.json(), async (req, res) => {
+        const snapshot = getLatestSessionSnapshot(processes, structured, storage, req.params.id);
+        if (!snapshot) {
+            res.status(404).json({ error: "未找到该会话。" });
+            return;
+        }
+        if (!snapshot.cwd) {
+            res.status(400).json({ error: "会话没有工作目录。", errorCode: "NO_CWD" });
+            return;
+        }
+        const body = (req.body ?? {});
+        try {
+            const result = await runTagHead({
+                cwd: snapshot.cwd,
+                language: config.language ?? "",
+                tag: typeof body.tag === "string" ? body.tag : undefined,
+                autoTag: !!body.autoTag,
+                push: !!body.push,
+            });
+            res.json(result);
+        }
+        catch (error) {
+            if (error instanceof QuickCommitError) {
+                const status = error.code === "TAG_EXISTS" ? 409 : 400;
+                res.status(status).json({ error: error.message, errorCode: error.code });
+                return;
+            }
+            res.status(400).json({ error: getErrorMessage(error, "打 tag 失败。") });
+        }
+    });
+    app.post("/api/sessions/:id/git/push", express.json(), async (req, res) => {
+        const snapshot = getLatestSessionSnapshot(processes, structured, storage, req.params.id);
+        if (!snapshot) {
+            res.status(404).json({ error: "未找到该会话。" });
+            return;
+        }
+        if (!snapshot.cwd) {
+            res.status(400).json({ error: "会话没有工作目录。", errorCode: "NO_CWD" });
+            return;
+        }
+        const body = (req.body ?? {});
+        try {
+            const result = await runPush({
+                cwd: snapshot.cwd,
+                pushCommits: body.pushCommits !== false,
+                pushTags: !!body.pushTags,
+            });
+            res.json(result);
+        }
+        catch (error) {
+            if (error instanceof QuickCommitError) {
+                res.status(400).json({ error: error.message, errorCode: error.code });
+                return;
+            }
+            res.status(400).json({ error: getErrorMessage(error, "推送失败。") });
+        }
+    });
     app.post("/api/sessions/:id/worktree/cleanup", (req, res) => {
         try {
             const current = requireWorktreeSession(getLatestSessionSnapshot(processes, structured, storage, req.params.id));