@co0ontty/wand 1.17.6 → 1.18.1

package/dist/process-manager.d.ts

@@ -44,6 +44,7 @@ export declare class ProcessManager extends EventEmitter {
         worktreeEnabled?: boolean;
         provider?: SessionProvider;
         model?: string;
+        reuseId?: string;
     }): SessionSnapshot;
     list(): SessionSnapshot[];
     /** Return lightweight snapshots for the session list (no output/messages). */
@@ -69,6 +70,7 @@ export declare class ProcessManager extends EventEmitter {
     private emitTask;
     resize(id: string, cols: number, rows: number): SessionSnapshot;
     stop(id: string): SessionSnapshot;
+    private cleanupRecord;
     delete(id: string): void;
     private deleteClaudeCache;
     runStartupCommands(): SessionSnapshot[];
@@ -104,8 +106,8 @@ export declare class ProcessManager extends EventEmitter {
     /**
      * Auto-recover the most recent exited session that has a Claude session ID.
      * Only resumes one session per server start, using the most recent eligible
-     * session. Sets `resumedToSessionId` on the original session and
-     * `autoRecovered: true` on the new session.
+     * session. Reuses the original session ID (in-place resume) and sets
+     * `autoRecovered: true`.
      */
     private autoRecoverExitedSessions;
     private archiveExpiredSessions;

package/dist/process-manager.js

@@ -608,13 +608,23 @@ export class ProcessManager extends EventEmitter {
             this.lastPersistedMessageState.delete(id);
             this.storage.deleteSession(id);
         }
+        if (toRemove.length > 0) {
+            this.claudeHistoryCache = null;
+        }
     }
     start(command, cwd, mode, initialInput, opts) {
         this.assertCommandAllowed(command);
         const baseCwd = cwd
             ? path.resolve(process.cwd(), cwd)
             : path.resolve(process.cwd(), this.config.defaultCwd);
-        const id = randomUUID();
+        const id = opts?.reuseId || randomUUID();
+        if (opts?.reuseId) {
+            const oldRecord = this.sessions.get(id);
+            if (oldRecord) {
+                this.cleanupRecord(oldRecord);
+                this.sessions.delete(id);
+            }
+        }
         const worktreeSetup = opts?.worktreeEnabled
             ? prepareSessionWorktree({ cwd: baseCwd, sessionId: id })
             : null;
@@ -690,6 +700,9 @@ export class ProcessManager extends EventEmitter {
         }
         this.sessions.set(id, record);
         this.persist(record);
+        if (initialClaudeSessionId) {
+            this.claudeHistoryCache = null;
+        }
         this.cleanupOldSessions();
         this.lifecycleManager.register(id, "initializing");
         const shellArgs = this.buildShellArgs(processedCommand);
@@ -800,6 +813,7 @@ export class ProcessManager extends EventEmitter {
             const bridgeSessionId = rec.ptyBridge?.getClaudeSessionId();
             if (bridgeSessionId && bridgeSessionId !== rec.claudeSessionId) {
                 rec.claudeSessionId = bridgeSessionId;
+                this.claudeHistoryCache = null;
                 process.stderr.write(`[wand] Captured Claude session ID: ${bridgeSessionId}\n`);
             }
             if (!rec.claudeSessionId && rec.knownClaudeTaskIds) {
@@ -1083,6 +1097,41 @@ export class ProcessManager extends EventEmitter {
         this.persist(record);
         return this.snapshot(record);
     }
+    cleanupRecord(record) {
+        if (record.taskDebounceTimer) {
+            clearTimeout(record.taskDebounceTimer);
+            record.taskDebounceTimer = null;
+        }
+        if (record.claudeTaskDiscoveryTimer) {
+            clearTimeout(record.claudeTaskDiscoveryTimer);
+            record.claudeTaskDiscoveryTimer = null;
+        }
+        if (record.initialInputTimer) {
+            clearTimeout(record.initialInputTimer);
+            record.initialInputTimer = null;
+        }
+        const pendingPersist = this.persistDebounceTimers.get(record.id);
+        if (pendingPersist) {
+            clearTimeout(pendingPersist);
+            this.persistDebounceTimers.delete(record.id);
+        }
+        if (record.status === "running") {
+            record.stopRequested = true;
+            if (record.childProcess) {
+                record.childProcess.kill();
+                record.childProcess = null;
+            }
+            if (record.ptyProcess) {
+                record.ptyProcess.kill();
+                record.ptyProcess = null;
+            }
+        }
+        if (record.ptyBridge) {
+            record.ptyBridge.removeAllListeners();
+            record.ptyBridge = null;
+        }
+        this.lifecycleManager.unregister(record.id);
+    }
     delete(id) {
         const record = this.mustGet(id);
         // Always clear pending timers
@@ -1135,6 +1184,9 @@ export class ProcessManager extends EventEmitter {
         this.sessions.delete(id);
         this.lastPersistedMessageState.delete(id);
         this.lifecycleManager.unregister(id);
+        if (record.claudeSessionId) {
+            this.claudeHistoryCache = null;
+        }
     }
     deleteClaudeCache(record) {
         if (!record.claudeSessionId)
@@ -1357,8 +1409,8 @@ export class ProcessManager extends EventEmitter {
     /**
      * Auto-recover the most recent exited session that has a Claude session ID.
      * Only resumes one session per server start, using the most recent eligible
-     * session. Sets `resumedToSessionId` on the original session and
-     * `autoRecovered: true` on the new session.
+     * session. Reuses the original session ID (in-place resume) and sets
+     * `autoRecovered: true`.
      */
     autoRecoverExitedSessions() {
         // Find eligible exited sessions
@@ -1393,19 +1445,12 @@ export class ProcessManager extends EventEmitter {
         }
         console.error(`[ProcessManager] Auto-recovering session ${original.id} with Claude session ID ${original.claudeSessionId}`);
         const resumeCommand = `${original.command.trim()} --resume ${original.claudeSessionId}`;
-        let newRecord = null;
         try {
             const snapshot = this.start(resumeCommand, original.cwd, original.mode, undefined, {
-                resumedFromSessionId: original.id,
+                reuseId: original.id,
                 autoRecovered: true
             });
-            newRecord = this.sessions.get(snapshot.id) ?? null;
-            if (!newRecord)
-                return;
-            // Set resumedToSessionId on the original session
-            original.resumedToSessionId = snapshot.id;
-            this.storage.saveSession(this.snapshot(original));
-            console.error(`[ProcessManager] Auto-recovered session ${snapshot.id} from ${original.id}`);
+            console.error(`[ProcessManager] Auto-recovered session ${snapshot.id} (in-place)`);
         }
         catch (err) {
             console.error(`[ProcessManager] Auto-recovery failed: ${String(err)}`);

package/dist/server-session-routes.js

@@ -406,8 +406,7 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
             }
             const newMode = body.mode ? normalizeMode(body.mode, defaultMode) : normalizeMode(existingSession.mode, defaultMode);
             const resumeCommand = `${command} --resume ${claudeSessionId}`;
-            const newSnapshot = processes.start(resumeCommand, existingSession.cwd, newMode, undefined, { resumedFromSessionId: sessionId });
-            storage.saveSession({ ...existingSession, resumedToSessionId: newSnapshot.id, archived: true });
+            const newSnapshot = processes.start(resumeCommand, existingSession.cwd, newMode, undefined, { reuseId: sessionId });
             res.status(201).json({ resumedFromSessionId: sessionId, ...newSnapshot });
         }
         catch (error) {
@@ -444,8 +443,7 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
                 }
                 const newMode = body.mode ? normalizeMode(body.mode, defaultMode) : normalizeMode(existingSession.mode, defaultMode);
                 const resumeCommand = `${command} --resume ${claudeSessionId}`;
-                const newSnapshot = processes.start(resumeCommand, existingSession.cwd, newMode, undefined, { resumedFromSessionId: existingSession.id });
-                storage.saveSession({ ...existingSession, resumedToSessionId: newSnapshot.id, archived: true });
+                const newSnapshot = processes.start(resumeCommand, existingSession.cwd, newMode, undefined, { reuseId: existingSession.id });
                 res.status(201).json({ resumedFromSessionId: existingSession.id, resumedClaudeSessionId: claudeSessionId, ...newSnapshot });
             }
             else {