@co0ontty/wand 4.89.5 → 4.90.0

package/dist/process-manager.d.ts

@@ -45,10 +45,29 @@ export interface ProcessManagerOptions {
     /** 本地决策入口；只有带首条提示词创建终端会话时用来结算「智能分配」。 */
     resolveDecisionEvaluate?: () => ((value: unknown, caller: string, signal?: AbortSignal) => Promise<DecisionResult>) | undefined;
 }
+export interface ProcessStartOptions extends Pick<SessionSnapshot, "employeeId" | "employeeName" | "employeeAvatar"> {
+    resumedFromSessionId?: string;
+    autoRecovered?: boolean;
+    worktreeEnabled?: boolean;
+    provider?: SessionProvider;
+    model?: string;
+    reuseId?: string;
+    cols?: number;
+    rows?: number;
+    thinkingEffort?: SessionSnapshot["thinkingEffort"];
+    sessionSource?: SessionSource;
+    automationId?: string;
+    workspaceId?: string;
+    workspaceTaskId?: string;
+    interactiveShell?: boolean;
+    systemPrompt?: string;
+}
 export declare class ProcessManager extends EventEmitter {
     private readonly config;
     private readonly storage;
     private readonly sessions;
+    /** Own the full start handshake, including model resolution and late host replies. */
+    private readonly startingSessions;
     private readonly logger;
     private readonly providerHistory;
     /** Quiet window for the non-Claude PTY turn tracker. */
@@ -59,8 +78,6 @@ export declare class ProcessManager extends EventEmitter {
     private readonly probePtyForegrounds;
     private readonly free;
     private readonly resolveDecisionEvaluate;
-    /** 24h archive scan timer */
-    private archiveTimer;
     /** 前台进程组采样定时器（见 samplePtyForegrounds） */
     private ptyForegroundTimer;
     /** 采样是 async 的，避免慢 ps 重叠成多个进程 */
@@ -129,24 +146,8 @@ export declare class ProcessManager extends EventEmitter {
     /** Stop all live work and flush pending state before storage is closed. */
     dispose(): void;
     private emitEvent;
-    private cleanupOldSessions;
-    start(command: string, cwd: string | undefined, mode: ExecutionMode, initialInput?: string, opts?: {
-        resumedFromSessionId?: string;
-        autoRecovered?: boolean;
-        worktreeEnabled?: boolean;
-        provider?: SessionProvider;
-        model?: string;
-        reuseId?: string;
-        cols?: number;
-        rows?: number;
-        thinkingEffort?: SessionSnapshot["thinkingEffort"];
-        sessionSource?: SessionSource;
-        automationId?: string;
-        workspaceId?: string;
-        workspaceTaskId?: string;
-        interactiveShell?: boolean;
-        systemPrompt?: string;
-    } & Pick<SessionSnapshot, "employeeId" | "employeeName" | "employeeAvatar">): Promise<SessionSnapshot>;
+    start(command: string, cwd: string | undefined, mode: ExecutionMode, initialInput?: string, opts?: ProcessStartOptions): Promise<SessionSnapshot>;
+    private startSession;
     list(): SessionSnapshot[];
     /** Return lightweight snapshots for the session list (no output/messages). */
     listSlim(): SessionSnapshot[];
@@ -172,6 +173,7 @@ export declare class ProcessManager extends EventEmitter {
     get(id: string): SessionSnapshot | null;
     /** Return only a session owned by this manager, without the SQLite fallback used by get(). */
     getOwned(id: string): SessionSnapshot | null;
+    getOwnedSlim(id: string): SessionSnapshot | null;
     getPtyTranscript(id: string): string | null;
     /**
      * Set the Claude model for an existing PTY session. Persists the selection
@@ -256,7 +258,6 @@ export declare class ProcessManager extends EventEmitter {
      * Use this at critical points (exit, stop, delete) to ensure no data loss.
      */
     private flushPersist;
-    private archiveExpiredSessions;
     private assertCommandAllowed;
     /**
      * @deprecated Only retained for non-Claude-CLI sessions without ptyBridge.

package/dist/process-manager.js

@@ -27,7 +27,6 @@ import { describePtySpawnFailure } from "./ensure-node-pty-helper.js";
 import { resolveSessionProvider, resolveSystemAiContext } from "./session-ai-context.js";
 import { resolveSessionCwd } from "./session-cwd.js";
 import { inferProviderFromCommand, isSessionProvider, providerCliCommand } from "./session-provider.js";
-import { RETENTION_IDLE_MS } from "./retention.js";
 import { PtyTerminalState } from "./pty-terminal-state.js";
 import { isPtySubmitInput } from "./pty-turn-activity.js";
 import { samplePtyForegrounds } from "./pty-foreground.js";
@@ -486,9 +485,6 @@ function restoreTerminalState(state) {
     }
     return terminal;
 }
-const MAX_SESSIONS = 200;
-// 会话空闲 7 天后在这里自动归档，再由保留期扫描于 7 天后清理。任务窗口在设置里单独配置。
-const ARCHIVE_AFTER_MS = RETENTION_IDLE_MS;
 const CONFIRM_WINDOW_SIZE = 800;
 /**
  * Quiet window for the non-Claude PTY turn tracker: a submitted turn stays busy
@@ -555,6 +551,8 @@ export class ProcessManager extends EventEmitter {
     config;
     storage;
     sessions = new Map();
+    /** Own the full start handshake, including model resolution and late host replies. */
+    startingSessions = new Map();
     logger;
     providerHistory = new ProviderHistoryScanner();
     /** Quiet window for the non-Claude PTY turn tracker. */
@@ -565,8 +563,6 @@ export class ProcessManager extends EventEmitter {
     probePtyForegrounds;
     free;
     resolveDecisionEvaluate;
-    /** 24h archive scan timer */
-    archiveTimer = null;
     /** 前台进程组采样定时器（见 samplePtyForegrounds） */
     ptyForegroundTimer = null;
     /** 采样是 async 的，避免慢 ps 重叠成多个进程 */
@@ -698,16 +694,6 @@ export class ProcessManager extends EventEmitter {
                 this.orphanRecoveredCount += 1;
             }
         }
-        this.archiveExpiredSessions();
-        this.archiveTimer = setInterval(() => {
-            try {
-                this.archiveExpiredSessions();
-            }
-            catch (err) {
-                console.error(`[ProcessManager] archive scan failed: ${String(err)}`);
-            }
-        }, 60 * 1000);
-        this.archiveTimer.unref?.();
         this.ptyForegroundTimer = setInterval(() => { void this.samplePtyForegrounds(); }, this.ptyForegroundSampleMs);
         this.ptyForegroundTimer.unref?.();
     }
@@ -1113,10 +1099,6 @@ export class ProcessManager extends EventEmitter {
         this.disposed = true;
         // 静默心跳不跨服务关闭存活；每个会话的 timer 也在 cleanupRecord 里单独撤销。
         this.ptyHeartbeat.dispose();
-        if (this.archiveTimer) {
-            clearInterval(this.archiveTimer);
-            this.archiveTimer = null;
-        }
         if (this.ptyForegroundTimer) {
             clearInterval(this.ptyForegroundTimer);
             this.ptyForegroundTimer = null;
@@ -1157,54 +1139,24 @@ export class ProcessManager extends EventEmitter {
             return;
         this.emit("process", event);
     }
-    cleanupOldSessions() {
-        // Only clean up when well over the limit
-        if (this.sessions.size < MAX_SESSIONS)
-            return;
-        const now = Date.now();
-        const STALE_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
-        const removable = [];
-        for (const [id, record] of this.sessions) {
-            // Only remove archived, non-running sessions older than 7 days
-            if (record.status === "running")
-                continue;
-            if (!record.archived)
-                continue;
-            const ref = record.endedAt ?? record.startedAt;
-            const refMs = Date.parse(ref);
-            if (Number.isFinite(refMs) && now - refMs > STALE_MS) {
-                removable.push(id);
-            }
-        }
-        // Sort oldest first and remove enough to get back under the limit
-        const toRemove = removable
-            .sort((a, b) => {
-            const ra = this.sessions.get(a);
-            const rb = this.sessions.get(b);
-            return (ra?.endedAt || "").localeCompare(rb?.endedAt || "");
-        })
-            .slice(0, this.sessions.size - MAX_SESSIONS + 1);
-        for (const id of toRemove) {
-            const record = this.sessions.get(id);
-            if (record) {
-                this.logger.deleteSession(id);
-                if (record.provider === "claude") {
-                    this.deleteClaudeCache(record);
-                }
-            }
-            this.sessions.delete(id);
-            this.terminalHost.forget(id);
-            this.lastPersistedMessageState.delete(id);
-            this.dirtySessions.delete(id);
-            this.storage.deleteSession(id);
-        }
-        if (toRemove.length > 0) {
-            this.providerHistory.invalidate();
-        }
-    }
     async start(command, cwd, mode, initialInput, opts) {
         if (this.disposed)
             throw new Error("ProcessManager has been disposed.");
+        const id = opts?.reuseId || randomUUID();
+        // Host operations are keyed by session id, not by the manager record. A
+        // second handshake must not adopt/forget a cancelled first incarnation.
+        if (this.startingSessions.has(id))
+            throw new Error("终端启动仍在进行，请等待本次启动结束后再恢复。");
+        const start = { cancelled: false };
+        this.startingSessions.set(id, start);
+        try {
+            return await this.startSession(id, start, command, cwd, mode, initialInput, opts);
+        }
+        finally {
+            this.startingSessions.delete(id);
+        }
+    }
+    async startSession(id, start, command, cwd, mode, initialInput, opts) {
         if (isOpenRouterFreeSelector(opts?.model))
             throw new Error("免费分组仅支持 Pi 结构化对话。");
         if (!opts?.interactiveShell)
@@ -1252,7 +1204,8 @@ export class ProcessManager extends EventEmitter {
         if (preferredModels.some(isOpenRouterFreeSelector))
             throw new Error("免费模型分组仅支持 Pi 结构化对话。");
         const baseCwd = resolveSessionCwd(cwd, this.config.defaultCwd);
-        const id = opts?.reuseId || randomUUID();
+        if (this.disposed || start.cancelled)
+            throw new Error("终端启动已取消。");
         // When a session is being resumed under the same id, capture its prior
         // structured messages so the new bridge can present them as the chat
         // history. We deliberately do NOT carry over rawOutput — `claude --resume`
@@ -1407,7 +1360,6 @@ export class ProcessManager extends EventEmitter {
         if (initialClaudeSessionId && (provider === "claude" || provider === "codex")) {
             this.providerHistory.invalidate(provider);
         }
-        this.cleanupOldSessions();
         let child;
         try {
             const attached = await this.terminalHost.createOrAttach({
@@ -1434,6 +1386,20 @@ export class ProcessManager extends EventEmitter {
                 throw new Error("Terminal host did not return a running process");
             }
             child = attached.process;
+            if (this.disposed || start.cancelled || this.sessions.get(id) !== record) {
+                // Explicit stop/delete still owns cancellation. Ordinary server shutdown
+                // only detaches persistent hosts: the next server must be able to adopt
+                // this in-progress spawn from the durable provisional record.
+                if (start.cancelled || !this.terminalHost.persistent) {
+                    try {
+                        child.kill();
+                    }
+                    catch { /* best-effort cancellation */ }
+                }
+                if (!this.disposed)
+                    this.terminalHost.forget(id);
+                throw new Error("终端启动已取消。");
+            }
             record.output = attached.state.output;
             record.storedOutput = attached.state.output;
             record.ptyOutputSeq = attached.state.seq;
@@ -1445,6 +1411,11 @@ export class ProcessManager extends EventEmitter {
             this.initializeClaudeBridge(record, attached.state.output);
         }
         catch (err) {
+            // stop/delete/dispose already committed the authoritative state. Neither
+            // a late success nor failure may remove or resurrect that state.
+            if (this.disposed || start.cancelled || this.sessions.get(id) !== record) {
+                throw new Error("终端启动已取消。");
+            }
             console.error("[ProcessManager] terminal spawn failed", { sessionId: id, error: String(err) });
             this.cleanupRecord(record, false);
             this.sessions.delete(id);
@@ -1749,6 +1720,11 @@ export class ProcessManager extends EventEmitter {
             result.output = record.storedOutput;
         return result;
     }
+    getOwnedSlim(id) {
+        this.terminalHost.flush?.();
+        const record = this.sessions.get(id);
+        return record ? this.snapshotSlim(record) : null;
+    }
     getPtyTranscript(id) {
         return this.logger.readPtyOutputTail(id);
     }
@@ -2004,6 +1980,9 @@ export class ProcessManager extends EventEmitter {
     }
     stop(id) {
         const record = this.mustGet(id);
+        const start = this.startingSessions.get(id);
+        if (start)
+            start.cancelled = true;
         if (record.status !== "running") {
             return this.snapshot(record);
         }
@@ -2109,6 +2088,9 @@ export class ProcessManager extends EventEmitter {
     }
     delete(id) {
         const record = this.mustGet(id);
+        const start = this.startingSessions.get(id);
+        if (start)
+            start.cancelled = true;
         // Always clear pending timers
         // 会话删除后迟到的回合回调要失效，静默心跳也不能再给不存在的会话发事件。
         this.ptyHeartbeat.cancel(id);
@@ -2563,22 +2545,6 @@ export class ProcessManager extends EventEmitter {
             messagesDirty: forceFullSave,
         });
     }
-    archiveExpiredSessions() {
-        const now = Date.now();
-        for (const record of this.sessions.values()) {
-            if (record.archived || record.status === "running") {
-                continue;
-            }
-            const referenceTime = record.endedAt ?? record.startedAt;
-            const endedAtMs = Date.parse(referenceTime);
-            if (!Number.isFinite(endedAtMs) || now - endedAtMs < ARCHIVE_AFTER_MS) {
-                continue;
-            }
-            record.archived = true;
-            record.archivedAt = new Date(now).toISOString();
-            this.persist(record);
-        }
-    }
     assertCommandAllowed(command) {
         if (!isCommandAllowedByPrefixes(command, this.config.allowedCommandPrefixes)) {
             throw new Error("Command is not allowed by current configuration.");

package/dist/prompt-optimizer.d.ts

@@ -1,4 +1,4 @@
-import { type QuickCommitAiOptions } from "./git-quick-commit.js";
+import { type QuickCommitAiOptions } from "./ai-text-runner.js";
 export declare class PromptOptimizeError extends Error {
     readonly code: string;
     constructor(message: string, code: string);

package/dist/prompt-optimizer.js

@@ -1,4 +1,4 @@
-import { callConfiguredAiText } from "./git-quick-commit.js";
+import { callConfiguredAiText } from "./ai-text-runner.js";
 const MAX_INPUT_LENGTH = 8000;
 export class PromptOptimizeError extends Error {
     code;

package/dist/render-host.js

@@ -1,6 +1,6 @@
 import { spawn } from "node:child_process";
 import { existsSync, readFileSync, unlinkSync } from "node:fs";
-import net from "node:net";
+import { probeUnixSocket as isSocketListening } from "./socket-probe.js";
 import process from "node:process";
 import { getErrorMessage } from "./error-utils.js";
 import { isExecutableFile, readRenderBinaryVersion, resolveRenderBinaryPath } from "./render-binary.js";
@@ -351,24 +351,6 @@ function reapUnreadyRender(pid) {
     const timer = setTimeout(() => signal("SIGKILL"), 500);
     timer.unref?.();
 }
-/** 对端是否真的在监听：区分「活着但拒绝 adopt」与「上一轮崩溃留下的孤儿 socket 文件」。 */ function isSocketListening(socketPath) {
-    return new Promise((resolve) => {
-        const socket = net.createConnection(socketPath);
-        let settled = false;
-        const finish = (alive) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            socket.destroy();
-            resolve(alive);
-        };
-        socket.once("connect", () => finish(true));
-        socket.once("error", () => finish(false));
-        const timer = setTimeout(() => finish(false), 300);
-        timer.unref?.();
-    });
-}
 function readLiveRenderPid(pidPath) {
     let pid;
     try {

package/dist/scheduled-task-service.d.ts

@@ -0,0 +1,41 @@
+import type { ConversationService } from "./conversation-service.js";
+import type { ScheduledTaskDetail, ScheduledTaskSummary } from "./scheduled-task-types.js";
+import type { WandStorage } from "./storage.js";
+import type { ProcessEvent, SessionSnapshot } from "./types.js";
+export declare class ScheduledTaskConflictError extends Error {
+}
+export declare class ScheduledTaskNotFoundError extends Error {
+}
+/** Scheduling owns durable occurrences; employee execution and retries remain in the normal conversation protocol. */
+export declare class ScheduledTaskService {
+    private readonly deps;
+    private timer;
+    private pendingTick;
+    private disposed;
+    private readonly liveAcceptedRuns;
+    constructor(deps: {
+        storage: WandStorage;
+        conversations: Pick<ConversationService, "send" | "receipt">;
+        getSession(id: string): SessionSnapshot | null;
+        defaultCwd?: () => string | undefined;
+        now?: () => Date;
+    });
+    private now;
+    private requireEmployee;
+    private requireWorkspaceCwd;
+    private executionDirectory;
+    private requireTask;
+    private runView;
+    private summary;
+    list(includeCancelled?: boolean): ScheduledTaskSummary[];
+    get(id: string): ScheduledTaskDetail;
+    create(value: unknown): ScheduledTaskSummary;
+    update(id: string, value: unknown): ScheduledTaskSummary;
+    private reconcile;
+    /** Capture the original turn's terminal fact before a user can start another turn in the same session. */
+    ingestSessionEvent(event: ProcessEvent): void;
+    tick(): Promise<void>;
+    private runTick;
+    start(intervalMs?: number): void;
+    dispose(): Promise<void>;
+}