@co0ontty/wand 4.41.0 → 4.42.0

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
-  "commit": "86d7332e9d197173cbabe647abdbbd7c50433814",
-  "builtAt": "2026-08-09T08:05:58.283Z",
-  "version": "4.41.0",
+  "commit": "0b6a7b8718c885c69a15d7ee14bd7383b4271459",
+  "builtAt": "2026-08-09T12:57:20.566Z",
+  "version": "4.42.0",
   "channel": "stable"
 }

package/dist/git-worktree.d.ts

@@ -42,6 +42,19 @@ export declare function resolveWorktreeTargetBranchAsync(cwd: string, gitTimeout
 /** 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>;
+/**
+ * Best-effort synchronous cleanup of a session/task worktree directory and its
+ * branch. Uses `--force` + `-D` (mirroring workspace-task deletion): deleting a
+ * session means discarding everything tied to it, including any uncommitted
+ * work in its isolated worktree. Any failure (already removed, locked, or a
+ * missing repo root) is swallowed so a stale or half-cleaned worktree can never
+ * block session deletion.
+ */
+export declare function cleanupWorktreeSync(worktree: {
+    path: string;
+    branch: string;
+    repoRoot?: string;
+} | null | undefined): void;
 /** Async HTTP-facing merge with serial, non-cancellable rollback. */
 export declare function mergeSessionWorktreeAsync(options: WorktreeMergeOptions): Promise<WorktreeMergeResult>;
 export declare function prepareSessionWorktree(options: WorktreeSetupOptions): WorktreeSetupResult;

package/dist/git-worktree.js

@@ -330,6 +330,27 @@ export async function checkSessionWorktreeMergeabilityAsync(options) {
 export async function cleanupSessionWorktreeAsync(options) {
     return cleanupMergedWorktreeAsync(await getMainRepoContextAsync(options));
 }
+/**
+ * Best-effort synchronous cleanup of a session/task worktree directory and its
+ * branch. Uses `--force` + `-D` (mirroring workspace-task deletion): deleting a
+ * session means discarding everything tied to it, including any uncommitted
+ * work in its isolated worktree. Any failure (already removed, locked, or a
+ * missing repo root) is swallowed so a stale or half-cleaned worktree can never
+ * block session deletion.
+ */
+export function cleanupWorktreeSync(worktree) {
+    const repoRoot = worktree?.repoRoot;
+    if (!repoRoot)
+        return;
+    try {
+        runGit(["worktree", "remove", "--force", worktree.path], repoRoot);
+    }
+    catch { /* best effort */ }
+    try {
+        runGit(["branch", "-D", worktree.branch], repoRoot);
+    }
+    catch { /* best effort */ }
+}
 /** Async HTTP-facing merge with serial, non-cancellable rollback. */
 export async function mergeSessionWorktreeAsync(options) {
     const context = await getMainRepoContextAsync(options);

package/dist/server-workspace-routes.js

@@ -4,8 +4,7 @@ import { existsSync, statSync } from "node:fs";
 import { asyncRoute } from "./express-async.js";
 import { getErrorMessage } from "./error-utils.js";
 import { expandHomePath } from "./middleware/path-safety.js";
-import { checkSessionWorktreeMergeabilityAsync, prepareSessionWorktree, resolveWorktreeTargetBranchAsync, } from "./git-worktree.js";
-import { runGit } from "./git-utils.js";
+import { checkSessionWorktreeMergeabilityAsync, cleanupWorktreeSync, prepareSessionWorktree, resolveWorktreeTargetBranchAsync, } from "./git-worktree.js";
 const PROVIDERS = new Set(["claude", "codex", "opencode", "grok", "qoder", "pi"]);
 function parseDefaultProvider(value) {
     return typeof value === "string" && PROVIDERS.has(value) ? value : undefined;
@@ -22,18 +21,6 @@ function resolveWorkspaceCwd(raw) {
         throw new Error(`不是目录：${resolved}`);
     return resolved;
 }
-function cleanupTaskWorktree(worktree) {
-    if (!worktree?.repoRoot)
-        return;
-    try {
-        runGit(["worktree", "remove", "--force", worktree.path], worktree.repoRoot);
-    }
-    catch { /* best effort */ }
-    try {
-        runGit(["branch", "-D", worktree.branch], worktree.repoRoot);
-    }
-    catch { /* best effort */ }
-}
 function deleteSessions(storage, sessions, sessionIds) {
     for (const sessionId of new Set(sessionIds)) {
         if (sessions)
@@ -252,7 +239,7 @@ export function registerWorkspaceRoutes(app, storage, sessions) {
         }
         for (const task of tasks) {
             if (cascade || task.worktree)
-                cleanupTaskWorktree(task.worktree);
+                cleanupWorktreeSync(task.worktree);
         }
         storage.deleteWorkspace(existing.id, { cascade });
         res.json({ ok: true });
@@ -440,7 +427,7 @@ export function registerWorkspaceRoutes(app, storage, sessions) {
         }
         // 尽力清理 worktree 与分支；失败不阻塞删除任务行。
         if (cascade)
-            cleanupTaskWorktree(existing.worktree);
+            cleanupWorktreeSync(existing.worktree);
         storage.deleteWorkspaceTask(existing.id, { cascade });
         res.json({ ok: true });
     });

package/dist/session-registry.js

@@ -1,3 +1,4 @@
+import { cleanupWorktreeSync } from "./git-worktree.js";
 function slimSnapshot(snapshot) {
     const { output: _output, messages: _messages, ...slim } = snapshot;
     return { ...slim, output: "" };
@@ -111,6 +112,18 @@ export class SessionRegistry {
         const snapshot = this.get(id);
         if (!snapshot)
             return null;
+        // Best-effort: tear down the session's isolated worktree (directory +
+        // branch) before removing the session record. Without this, deleting a
+        // session that was never merged leaves an orphan under `.wand-worktrees/`
+        // and a dangling `wand/*` branch forever — the merge path is the only
+        // other place that cleans them up. Force removal is intentional: deleting
+        // a session means discarding everything tied to it.
+        if (snapshot.worktree) {
+            try {
+                cleanupWorktreeSync(snapshot.worktree);
+            }
+            catch { /* never block deletion */ }
+        }
         const owner = this.ownerOf(id);
         if (owner === "structured")
             this.structured.delete(id);