@co0ontty/wand 4.106.0 → 4.106.1

package/dist/server-workspace-routes.js

@@ -97,6 +97,13 @@ function sortTaskDirectoryGroups(groups, order) {
         const global = Number(Boolean(right.global)) - Number(Boolean(left.global));
         if (global)
             return global;
+        const leftHasContent = (left.tasks?.length ?? 0) > 0 || (left.standaloneSessions?.length ?? 0) > 0;
+        const rightHasContent = (right.tasks?.length ?? 0) > 0 || (right.standaloneSessions?.length ?? 0) > 0;
+        if (leftHasContent !== rightHasContent)
+            return rightHasContent ? 1 : -1;
+        const activity = compareCreatedDesc(left.latestActivityAt ?? left.createdAt, right.latestActivityAt ?? right.createdAt);
+        if (activity)
+            return activity;
         const created = compareCreatedDesc(left.createdAt, right.createdAt);
         if (created)
             return created;
@@ -133,6 +140,8 @@ function rememberCreatedAt(target, iso) {
         return;
     if (!target.createdAt || value < target.createdAt)
         target.createdAt = value;
+    if (!target.latestActivityAt || value > target.latestActivityAt)
+        target.latestActivityAt = value;
 }
 function parseDefaultProvider(value) {
     return isSessionProvider(value) ? value : undefined;
@@ -466,7 +475,7 @@ export function registerWorkspaceRoutes(app, storage, sessions, titleOptions = {
                 cleanupWorktreeSync(task.worktree);
             const card = storage.getWandTaskByWorkspaceTaskId(task.id);
             if (card)
-                storage.updateWandTask(card.id, { status: "archived", workspaceTaskId: null });
+                storage.archiveTaskForWorkspaceRemoval(card.id);
         }
         storage.deleteWorkspace(existing.id, { cascade });
         res.json({ ok: true });
@@ -558,6 +567,47 @@ export function registerWorkspaceRoutes(app, storage, sessions, titleOptions = {
         }
         res.json(result);
     }));
+    // Sections are layout containers, independent of task-board metadata.
+    app.post("/api/workspace-sections", (req, res) => {
+        try {
+            const name = typeof req.body?.name === "string" ? req.body.name.trim() : "";
+            if (!name)
+                throw badRequest("请输入分区名称。");
+            const cwd = resolveWorkspaceCwd(req.body?.cwd);
+            const workspaceId = typeof req.body?.workspaceId === "string" ? req.body.workspaceId : "";
+            const workspace = workspaceId ? storage.getWorkspace(workspaceId)
+                : storage.listWorkspaces().find(candidate => !isGlobalWorkspace(candidate)
+                    && normalizeProjectCwd(candidate.cwd) === normalizeProjectCwd(cwd)) ?? storage.ensureGlobalWorkspace();
+            if (!workspace)
+                throw badRequest("未找到工作区。");
+            if (!isGlobalWorkspace(workspace) && normalizeProjectCwd(workspace.cwd) !== normalizeProjectCwd(cwd)) {
+                throw badRequest("分区目录与工作区不一致。");
+            }
+            const sessionId = typeof req.body?.sessionId === "string" ? req.body.sessionId.trim() : undefined;
+            const section = storage.createWorkspaceSection({ workspaceId: workspace.id, name, cwd, sessionId });
+            if (sessionId)
+                sessions?.refreshSessionWorkspace(sessionId);
+            res.status(201).json({ ...section, sessions: [], isolated: false });
+        }
+        catch (error) {
+            sendRouteError(res, error, "无法创建分区。");
+        }
+    });
+    app.post("/api/workspace-sections/unassign", (req, res) => {
+        try {
+            const sessionId = typeof req.body?.sessionId === "string" ? req.body.sessionId.trim() : "";
+            if (!storage.getSessionSlim(sessionId)) {
+                res.status(404).json({ error: "未找到会话。" });
+                return;
+            }
+            storage.moveSessionToWorkspaceTask(sessionId, null);
+            sessions?.refreshSessionWorkspace(sessionId);
+            res.json({ ok: true });
+        }
+        catch (error) {
+            sendRouteError(res, error, "无法移回工作区。");
+        }
+    });
     // 两个创建入口只在项目来源上不同；独立任务挂到隐藏全局空间。
     // 默认只创建逻辑分组，仅显式 worktree:true 才创建隔离目录。
     app.post(["/api/tasks", "/api/workspaces/:id/tasks"], asyncRoute(async (req, res) => {
@@ -601,7 +651,7 @@ export function registerWorkspaceRoutes(app, storage, sessions, titleOptions = {
         const snapshots = sessions?.listSlim();
         const revision = crypto.createHash("sha256").update(JSON.stringify({
             storage: storage.projectionRevision(),
-            projection: "workspace-work-sessions-v2-queued",
+            projection: "workspace-work-sessions-v3-task-status",
             query: { includeArchived, workspaceFilter, taskLimit, sessionLimit },
             runtime: snapshots,
         })).digest("base64url");
@@ -682,17 +732,19 @@ export function registerWorkspaceRoutes(app, storage, sessions, titleOptions = {
             target.tasks.push({
                 ...task,
                 boardTaskId: board?.id ?? null,
+                boardTaskStatus: board?.status ?? null,
                 ...(board ? model.execution(board) : taskExecutionProjection(visibleSessions)),
                 parentWorkspaceTaskId: parent?.workspaceTaskId ?? null,
-                canArchive: (() => { const card = model.cardsByContainer.get(task.id); return card ? model.canArchive(card) : true; })(),
+                canArchive: task.kind !== "section" && (() => { const card = model.cardsByContainer.get(task.id); return card ? model.canArchive(card) : true; })(),
                 ...model.milestone(task.milestoneId),
                 cwd: taskRuntimeCwd(task, workspace),
                 isolated: task.worktree !== null,
                 sessions,
                 totalSessions: visibleSessions.length,
             });
-            if (target.synthetic)
-                rememberCreatedAt(target, task.createdAt);
+            rememberCreatedAt(target, task.createdAt);
+            for (const session of visibleSessions)
+                rememberCreatedAt(target, session.startedAt);
         };
         for (const workspace of visibleWorkspaces) {
             const base = groups.get(workspace.id);
@@ -788,8 +840,17 @@ export function registerWorkspaceRoutes(app, storage, sessions, titleOptions = {
             group.standaloneSessions.push(summarize(session, {
                 workspaceName: group.workspaceName,
             }));
-            if (group.synthetic)
-                rememberCreatedAt(group, session.startedAt);
+            rememberCreatedAt(group, session.startedAt);
+        }
+        // 目录内的任务与会话排序：新创建的必须在上面（严格按创建/启动时间倒序）。
+        for (const group of groups.values()) {
+            group.tasks.sort((left, right) => compareCreatedDesc(left.createdAt, right.createdAt));
+            for (const task of group.tasks) {
+                if (Array.isArray(task.sessions)) {
+                    task.sessions.sort((left, right) => compareCreatedDesc(left.startedAt, right.startedAt));
+                }
+            }
+            group.standaloneSessions.sort((left, right) => compareCreatedDesc(left.startedAt, right.startedAt));
         }
         const orderedGroups = [...groups.values()]
             .filter((group) => !group.global || group.tasks.length > 0 || group.standaloneSessions.length > 0);
@@ -993,6 +1054,10 @@ export function registerWorkspaceRoutes(app, storage, sessions, titleOptions = {
             res.status(404).json({ error: "未找到该任务。" });
             return;
         }
+        if (existing.kind === "section") {
+            res.status(409).json({ error: "分区不需要归档，可删除分区并保留会话。" });
+            return;
+        }
         const card = storage.getWandTaskByWorkspaceTaskId(existing.id);
         if (card && !canArchiveTask(storage, sessions, card.id)) {
             res.status(409).json({ error: "任务尚未完成或仍有执行，完成后才能归档。" });
@@ -1018,16 +1083,19 @@ export function registerWorkspaceRoutes(app, storage, sessions, titleOptions = {
         }
         // 删除隔离任务必然会移除其 cwd，因此即使调用方没有显式传 cascade，
         // 也必须同步删除会话；非隔离任务仍保留旧的“默认解绑”API 语义。
-        const cascade = req.query.cascade === "1"
+        const cascade = existing.kind !== "section" && (req.query.cascade === "1"
             || req.query.cascade === "true"
-            || existing.worktree !== null;
+            || existing.worktree !== null);
         if (cascade) {
             deleteSessions(storage, sessions, storage.listSessionsByWorkspaceTaskSlim(existing.id).map((session) => session.id));
         }
         // 尽力清理 worktree 与分支；失败不阻塞删除任务行。
         if (cascade)
             cleanupWorktreeSync(existing.worktree);
+        const retained = !cascade ? storage.listSessionsByWorkspaceTaskSlim(existing.id).map(session => session.id) : [];
         storage.deleteWorkspaceTask(existing.id, { cascade });
+        for (const id of retained)
+            sessions?.refreshSessionWorkspace(id);
         res.json({ ok: true });
     });
     // 保存任务的标签 / 分屏布局

package/dist/server.js

@@ -16,6 +16,7 @@ import { AuthService, principalHasScope, } from "./auth.js";
 import { authenticateBearerAppToken, createRequireAuth, getEffectivePassword, requireAdmin as requireAdminScope, requireAdminOrSessionPreferences, requireScope, } from "./middleware/auth.js";
 import { createApiScopeMiddleware } from "./middleware/api-scope.js";
 import { createExtensionCors } from "./middleware/cors.js";
+import { RUNNING_BUILD_INFO as BUILD_INFO } from "./build-info.js";
 import { ensureCertificates } from "./cert.js";
 import { getDefaultModelForProvider, getProviderDefaultModels, resolveConfigDir, writePreferenceToStorage, } from "./config.js";
 import { ModelCatalogService } from "./models.js";
@@ -83,6 +84,7 @@ import { registerClaudeHistoryRoutes, registerSessionRoutes } from "./server-ses
 import { registerWorkspaceRoutes } from "./server-workspace-routes.js";
 import { backfillSessionWorkspaces } from "./workspace-binding.js";
 import { getErrorMessage } from "./error-utils.js";
+import { stopIterationPrompts, whenIterationPromptsSettled } from "./iteration-log.js";
 import { asyncRoute, jsonErrorHandler } from "./express-async.js";
 import { FeedbackReceiver, FeedbackReporter } from "./feedback.js";
 import { feedbackFeatureForApiPath } from "./feedback-feature-map.js";
@@ -111,8 +113,10 @@ import { registerDaemonMaintenanceRoutes } from "./server-daemon-maintenance-rou
 import { terminalDaemonBuildIsCurrent } from "./terminal-daemon-build.js";
 import { createUpgradeAwareStructuredHost } from "./render-structured-host.js";
 import { PiTmuxHost } from "./pi-tmux-host.js";
+import { PtyTmuxBackend } from "./pty-tmux-backend.js";
 import { StructuredTmuxHost } from "./structured-tmux-host.js";
-import { tmuxEnabled } from "./tmux-policy.js";
+import { logInfo } from "./runtime-log.js";
+import { probeTmuxSupport, tmuxEnabled } from "./tmux-policy.js";
 import { structuredHostMaintenance } from "./structured-host-maintenance.js";
 import { createTmuxTerminalHost } from "./tmux-terminal-host.js";
 import { updateProviderClis, verifyProviderCliUpdateResults, } from "./provider-cli-updater.js";
@@ -140,31 +144,13 @@ async function checkLatestPackageVersion(channel, forceRefresh = false) {
     }
     // The immutable running build is also what the UI reports. Shared package metadata may
     // belong to a different installer; it must not make a local Beta look like an older stable.
-    const info = await checkPackageUpdateAsync(DISPLAY_VERSION, channel);
+    const info = await checkPackageUpdateAsync(DISPLAY_VERSION, channel, undefined, BUILD_INFO);
     if (info.latest) {
         packageUpdateCache.set(channel, { info, timestamp: now });
     }
     return info;
 }
 // ── Build info (构建时打入的 commit SHA) + Beta 通道 ──
-/** 读取 dist/build-info.json（由 scripts/stamp-build-info.js 在 build 时生成）。 */
-function readBuildInfo() {
-    try {
-        const raw = readFileSync(path.join(SERVER_MODULE_DIR, "build-info.json"), "utf8");
-        const j = JSON.parse(raw);
-        return {
-            commit: typeof j.commit === "string" && j.commit ? j.commit : null,
-            builtAt: typeof j.builtAt === "string" && j.builtAt ? j.builtAt : null,
-            version: typeof j.version === "string" && j.version ? j.version : null,
-            channel: typeof j.channel === "string" && j.channel ? j.channel : null,
-        };
-    }
-    catch {
-        // dev（tsx 跑 src/）或老版本（无此文件）时降级为全 null。
-        return { commit: null, builtAt: null, version: null, channel: null };
-    }
-}
-const BUILD_INFO = readBuildInfo();
 const DISPLAY_VERSION = BUILD_INFO.version || PKG_VERSION;
 const SERVER_INSTANCE_ID = crypto.randomUUID();
 // ── Startup error handling ──
@@ -308,8 +294,11 @@ export async function startServer(config, configPath, options = {}) {
         const ensured = formatManagedSkillsEnsureLog(await ensureManagedSkills(configPath));
         if (ensured)
             process.stdout.write(ensured);
+        storage.syncGlobalKnowledge();
     }
     let notifyFreeDefaultChanged = (_employeeId) => { };
+    let collectNativeRunArtifacts = null;
+    let collectPtyTmuxArtifacts = null;
     const systemFallback = testMode || process.env.WAND_DISABLE_OPENCODE_FALLBACK === "1" ? undefined : new OpenCodeFreeModelsService({ configDir,
         storage, inheritEnv: config.inheritEnv, onLog: line => process.stdout.write(`[wand] ${line}\n`),
         onModelsChanged(models) {
@@ -352,11 +341,11 @@ export async function startServer(config, configPath, options = {}) {
                 freedBytes: results.reduce((total, result) => total + result.freedBytes, 0),
             };
         },
-        // Pi 原生回合目录（pi-native/）按回合数增长，同样交给同一轮定时回收。
-        collectNativeArtifacts: () => structuredSessions.collectNativeGarbage({
-            liveSessionIds: new Set(sessionRegistry.listSlim().map((session) => session.id)),
-            retentionMs: STORAGE_CLEANUP_RETENTION_DAYS * 24 * 60 * 60 * 1000,
-        }),
+        // Pi 原生回合目录（pi-native/）和 structured-tmux 按回合数增长，交给同一轮定时回收。
+        // 只保护未归档会话。已删除或已归档的 slot 在 ack 完成、进程退出后整槽删除。
+        // 宿主在下面才包好，这里先留空，避免清理闭包引用尚未赋值的变量。
+        collectNativeArtifacts: () => collectNativeRunArtifacts?.() ?? null,
+        collectPtyTmuxArtifacts: () => collectPtyTmuxArtifacts?.() ?? null,
         // 旧版本遗留的迁移前快照：无上限堆积。迁移成功路径已在 storage-schema 修剪。
         pruneMigrationSnapshots: () => pruneMigrationBackups(databasePath, { dryRun: false }) });
     const localModels = new LocalModelSetupService({ configDir, decisions,
@@ -391,6 +380,15 @@ export async function startServer(config, configPath, options = {}) {
     const tmuxTerminals = options.terminalHost
         ? { host: ptyHosts.host, client: null, configPath, maintenanceTarget: undefined }
         : await createTmuxTerminalHost(configPath, ptyHosts.host);
+    if (tmuxEnabled()) {
+        const probe = probeTmuxSupport();
+        if (probe.ok) {
+            logInfo(`tmux runtime active (${probe.version}, ${probe.path}); terminal and structured CLI runs hosted.`);
+        }
+        else {
+            wandWarn(`tmux 执行底座检查未通过: ${probe.error}`);
+        }
+    }
     const daemonAdmission = new DaemonAdmission();
     const terminalHost = daemonAdmission.terminal(tmuxTerminals.host);
     let decisionRuntime = null;
@@ -404,17 +402,43 @@ export async function startServer(config, configPath, options = {}) {
         ?? (ptyHosts.host instanceof TerminalDaemonClient ? ptyHosts.host : null);
     const structuredHosts = await createUpgradeAwareStructuredHost(configPath, legacyStructuredHost, config.structured?.processHost);
     let structuredHost = structuredHosts.host;
+    let structuredTmuxHost = null;
     if (structuredHost?.persistent) {
         const enabled = tmuxEnabled();
-        const tmuxHost = new StructuredTmuxHost(configDir, structuredHost, enabled);
+        structuredTmuxHost = new StructuredTmuxHost(configDir, structuredHost, enabled);
         // Keep both routes available after disabling new tmux launches: existing
         // native and generic runs still belong to their original persistent owner.
-        structuredHost = new PiTmuxHost(configDir, tmuxHost, enabled && process.env.WAND_PI_NATIVE_TMUX !== "0");
+        structuredHost = new PiTmuxHost(configDir, structuredTmuxHost, enabled && process.env.WAND_PI_NATIVE_TMUX !== "0");
     }
     const structuredSessions = new StructuredSessionManager(storage, config, structuredLogger, {}, structuredHost ? daemonAdmission.structured(structuredHost) : undefined, () => decisionRuntime, openRouter, () => autoAssignEvaluate, webLoginTickets);
     // No SDK prewarm: Pi defaults to CLI. Only an explicit Wand Agent selection
     // probes the in-process harness; CLI startup/settings must not depend on it.
     const sessionRegistry = new SessionRegistry(processes, structuredSessions, storage);
+    collectNativeRunArtifacts = () => {
+        const activeSessionIds = new Set(sessionRegistry.listSlim().filter((session) => !session.archived).map((session) => session.id));
+        const retentionMs = STORAGE_CLEANUP_RETENTION_DAYS * 24 * 60 * 60 * 1000;
+        const hosts = [structuredHost, structuredTmuxHost].filter((host) => Boolean(host?.collectGarbage));
+        let removedSlots = 0;
+        let removedTurns = 0;
+        let freedBytes = 0;
+        let ran = false;
+        for (const host of hosts) {
+            const part = host.collectGarbage?.({ liveSessionIds: activeSessionIds, activeSessionIds, retentionMs });
+            if (!part)
+                continue;
+            ran = true;
+            removedSlots += part.removedSlots;
+            removedTurns += part.removedTurns;
+            freedBytes += part.freedBytes;
+        }
+        const report = ran ? { removedSlots, removedTurns, freedBytes } : null;
+        return report;
+    };
+    collectPtyTmuxArtifacts = () => {
+        const activeSessionIds = new Set(sessionRegistry.listSlim().filter((session) => !session.archived).map((session) => session.id));
+        const retentionMs = STORAGE_CLEANUP_RETENTION_DAYS * 24 * 60 * 60 * 1000;
+        return PtyTmuxBackend.collectGarbage(configDir, { activeSessionIds, retentionMs });
+    };
     // 员工任务并发闸门：所有员工派发共用同一实例，排队状态随存储持久化。
     const taskExecutionQueue = new TaskExecutionQueue({
         storage, config, structured: structuredSessions, processes, sessions: sessionRegistry,
@@ -912,14 +936,14 @@ export async function startServer(config, configPath, options = {}) {
             while (structuredSessions.getCoreTurnStatus().hasActiveTurns) {
                 await new Promise((resolve) => setTimeout(resolve, 1000));
             }
-            // Do not dispose tools/services or arm the force-exit timer while a native
-            // turn is still running. The same barrier covers manual and auto restart.
+            // Do not dispose tools/services while a native turn is still running.
+            // The same barrier covers manual and auto restart.
             const plan = computeRelaunch({
                 serviceInstalled: safeServiceInstalled(),
                 globalCli: resolveGlobalWandCli(),
             });
-            const forceExitTimer = setTimeout(() => process.exit(0), 5000);
-            forceExitTimer.unref?.();
+            // Accepted iteration records can need the bounded Git compatibility retry;
+            // a force-exit timer here would discard them before close() drains the queue.
             await close();
             if (plan.mode === "spawn") {
                 spawn(process.execPath, [plan.bin ?? "", ...(plan.args ?? [])], {
@@ -964,6 +988,7 @@ export async function startServer(config, configPath, options = {}) {
     await new Promise((resolve, reject) => {
         const cleanupFailedListen = async () => {
             shuttingDown = true;
+            stopIterationPrompts(storage);
             dingtalk.dispose();
             dingtalkDws.dispose();
             employeeImLifecycle.dispose();
@@ -1008,17 +1033,20 @@ export async function startServer(config, configPath, options = {}) {
             authService.dispose();
             taskExecutionQueue.dispose();
             try {
+                await whenIterationPromptsSettled(storage);
+            }
+            finally {
                 storage.close();
             }
-            catch { /* noop */ }
         };
         const onListenError = (err) => {
             feedback.capture("startup_failed", err);
             feedback.stop();
             server.off("error", onListenError);
+            const startupError = err.code === "EADDRINUSE" ? new PortInUseError(config.port, config.host) : err;
             void cleanupFailedListen().then(() => {
-                reject(err.code === "EADDRINUSE" ? new PortInUseError(config.port, config.host) : err);
-            }, reject);
+                reject(startupError);
+            }, cleanupError => reject(new AggregateError([startupError, cleanupError], "Server startup rollback failed")));
         };
         server.once("error", onListenError);
         server.listen(config.port, config.host, () => {
@@ -1082,6 +1110,7 @@ export async function startServer(config, configPath, options = {}) {
         storage,
         sessions: sessionRegistry,
         taskRetention: () => config.taskRetention,
+        releaseArchivedProviderHistory: (sessionIds) => sessionRegistry.releaseArchivedProviderHistory(sessionIds),
     };
     const sweepRetention = createRetentionSweep(retentionDeps);
     runTaskRetentionSweep = () => {
@@ -1244,6 +1273,7 @@ export async function startServer(config, configPath, options = {}) {
             return closePromise;
         closePromise = (async () => {
             shuttingDown = true;
+            stopIterationPrompts(storage);
             feedback.stop();
             if (activeFeedback === feedback)
                 activeFeedback = null;
@@ -1343,9 +1373,11 @@ export async function startServer(config, configPath, options = {}) {
                 // can never retain or call a closed storage instance.
                 authService.dispose();
                 try {
+                    await whenIterationPromptsSettled(storage);
+                }
+                finally {
                     storage.close();
                 }
-                catch { /* ignore */ }
             }
         })();
         return closePromise;

package/dist/session-registry.d.ts

@@ -53,13 +53,27 @@ export declare class SessionRegistry {
     setSessionThinkingEffort(id: string, effort: SessionSnapshot["thinkingEffort"]): SessionSnapshot | null;
     setSessionMode(id: string, mode: ExecutionMode): SessionSnapshot | null;
     setSessionTopic(id: string, title: string, description: string): SessionSnapshot | null;
+    /** 停掉空闲 PTY 壳。保留期只对「进程还在、但没有正在处理的回合」调用。 */
+    stop(id: string): SessionSnapshot | null;
     /**
-     * 归档 / 取消归档一个会话：只写标记，不杀进程、不删历史；真正的清理留给保留期扫描。
+     * 归档 / 取消归档一个会话：不杀进程。归档后这次对话不再续接，
+     * 立刻删掉 CLI 原生历史，避免 ~/.pi、~/.codex 这类目录继续堆积；
+     * 取消归档时把原生 id 移出隐藏名单，已有的 CLI 历史可以继续恢复。
      * 会话可能只存在于 storage（重启后未加载），因此 storage-only 也要能改。
      */
-    /** 停掉空闲 PTY 壳。保留期只对「进程还在、但没有正在处理的回合」调用。 */
-    stop(id: string): SessionSnapshot | null;
     setArchived(id: string, archived: boolean): SessionSnapshot | null;
+    /**
+     * 归档与 CLI 原生历史的对应关系。别的未归档会话还在用同一个原生 id 时不动。
+     * 删文件失败只记日志：归档标记已经写上，不能因为清理失败把请求打回去。
+     */
+    private syncArchivedProviderHistory;
+    /**
+     * 清掉这些已归档会话独占的 CLI 原生历史，并记入隐藏名单。
+     * 同一个原生 id 仍被未归档会话使用时跳过。重复调用只是再删一次已不存在的文件。
+     */
+    releaseArchivedProviderHistory(sessionIds: readonly string[]): void;
+    /** 另一个未归档会话是否还拿着同一个 CLI 原生 id。 */
+    private activeNativeOwner;
     updateWorktreeState(id: string, status: SessionSnapshot["worktreeMergeStatus"], info: SessionSnapshot["worktreeMergeInfo"]): SessionSnapshot | null;
     private deleteManagedSession;
     /** All destructive paths, including retention, remove native session artifacts. */

package/dist/session-registry.js

@@ -259,16 +259,18 @@ export class SessionRegistry {
             return this.processes.setSessionTopic(id, title, description);
         return this.updateStored(id, (snapshot) => ({ ...snapshot, title, description, summary: description }));
     }
-    /**
-     * 归档 / 取消归档一个会话：只写标记，不杀进程、不删历史；真正的清理留给保留期扫描。
-     * 会话可能只存在于 storage（重启后未加载），因此 storage-only 也要能改。
-     */
     /** 停掉空闲 PTY 壳。保留期只对「进程还在、但没有正在处理的回合」调用。 */
     stop(id) {
         if (this.ownerOf(id) !== "pty")
             return this.get(id);
         return this.processes.stop(id);
     }
+    /**
+     * 归档 / 取消归档一个会话：不杀进程。归档后这次对话不再续接，
+     * 立刻删掉 CLI 原生历史，避免 ~/.pi、~/.codex 这类目录继续堆积；
+     * 取消归档时把原生 id 移出隐藏名单，已有的 CLI 历史可以继续恢复。
+     * 会话可能只存在于 storage（重启后未加载），因此 storage-only 也要能改。
+     */
     setArchived(id, archived) {
         const current = this.getLatest(id);
         if (current && !!current.archived === archived && (!archived || current.archivedAt))
@@ -277,15 +279,66 @@ export class SessionRegistry {
             throw Object.assign(new Error("会话仍在执行或等待处理，完成后才能归档。"), { statusCode: 409 });
         }
         const owner = this.ownerOf(id);
-        if (owner === "structured")
-            return this.structured.setSessionArchived(id, archived);
-        if (owner === "pty")
-            return this.processes.setSessionArchived(id, archived);
-        return this.updateStored(id, (snapshot) => ({
-            ...snapshot,
-            archived,
-            archivedAt: archived ? new Date().toISOString() : null,
-        }));
+        const updated = owner === "structured"
+            ? this.structured.setSessionArchived(id, archived)
+            : owner === "pty"
+                ? this.processes.setSessionArchived(id, archived)
+                : this.updateStored(id, (snapshot) => ({
+                    ...snapshot,
+                    archived,
+                    archivedAt: archived ? new Date().toISOString() : null,
+                }));
+        if (updated)
+            this.syncArchivedProviderHistory(updated);
+        return updated;
+    }
+    /**
+     * 归档与 CLI 原生历史的对应关系。别的未归档会话还在用同一个原生 id 时不动。
+     * 删文件失败只记日志：归档标记已经写上，不能因为清理失败把请求打回去。
+     */
+    syncArchivedProviderHistory(snapshot) {
+        if (!snapshot.archived) {
+            const providerSessionId = snapshot.claudeSessionId?.trim();
+            if (!providerSessionId)
+                return;
+            const provider = sessionProvider(snapshot);
+            const shared = this.activeNativeOwner(snapshot.id, provider, providerSessionId);
+            if (!shared)
+                removeHiddenSessionIds(this.storage, [providerSessionId]);
+            return;
+        }
+        this.releaseArchivedProviderHistory([snapshot.id]);
+    }
+    /**
+     * 清掉这些已归档会话独占的 CLI 原生历史，并记入隐藏名单。
+     * 同一个原生 id 仍被未归档会话使用时跳过。重复调用只是再删一次已不存在的文件。
+     */
+    releaseArchivedProviderHistory(sessionIds) {
+        const wanted = new Set(sessionIds);
+        for (const snapshot of this.listSlim()) {
+            if (!wanted.has(snapshot.id) || !snapshot.archived)
+                continue;
+            const providerSessionId = snapshot.claudeSessionId?.trim();
+            if (!providerSessionId)
+                continue;
+            const provider = sessionProvider(snapshot);
+            if (this.activeNativeOwner(snapshot.id, provider, providerSessionId))
+                continue;
+            addHiddenSessionIds(this.storage, [providerSessionId]);
+            try {
+                deleteProviderNativeHistory(this.processes, provider, providerSessionId, snapshot.cwd);
+            }
+            catch {
+                logInfo("[SessionCleanup] Archived CLI session cleanup could not complete; artifacts were preserved.");
+            }
+        }
+    }
+    /** 另一个未归档会话是否还拿着同一个 CLI 原生 id。 */
+    activeNativeOwner(sessionId, provider, providerSessionId) {
+        return this.listSlim().some((other) => other.id !== sessionId
+            && !other.archived
+            && other.claudeSessionId?.trim() === providerSessionId
+            && sessionProvider(other) === provider);
     }
     updateWorktreeState(id, status, info) {
         const owner = this.ownerOf(id);

package/dist/session-service.js

@@ -55,7 +55,7 @@ export function getInputErrorResponse(error, sessionId) {
         };
     }
     const errorCode = error?.code;
-    if (errorCode === "duplicate_queued_message" || errorCode === "duplicate_idempotency_key") {
+    if (errorCode === "duplicate_queued_message" || errorCode === "duplicate_idempotency_key" || errorCode === "idempotency_key_conflict") {
         return {
             statusCode: 409,
             payload: {

package/dist/storage/internal.d.ts

@@ -44,13 +44,14 @@ export interface CreateWandTaskInput {
     priority?: WandTask["priority"];
     labels?: string[];
     dueDate?: string | null;
+    cwd?: string | null;
     milestoneId?: string | null;
     agent?: WandTaskAgent | null;
     executionSubject?: WandTask["executionSubject"];
 }
-export type WandTaskPatch = Partial<Pick<WandTask, "workspaceId" | "workspaceTaskId" | "parentTaskId" | "title" | "titleSource" | "autoTitleSignature" | "description" | "status" | "priority" | "labels" | "dueDate" | "milestoneId" | "sortOrder" | "agent" | "executionSubject" | "acceptance">>;
-export declare const WAND_TASK_FIELDS = "id, identifier, workspace_id, workspace_task_id, parent_task_id,\n  title, title_source, auto_title_signature, description, status, priority, labels_json,\n  due_date, milestone_id, sort_order, agent_json, execution_subject_json, archived_at, created_at, updated_at, acceptance_json";
-export declare const WORKSPACE_TASK_PROJECTION = "SELECT wt.id,\n  CASE WHEN card.id IS NULL THEN wt.workspace_id\n    ELSE COALESCE(card.workspace_id, 'wand-global') END AS workspace_id,\n  CASE WHEN card.id IS NULL THEN wt.name ELSE card.title END AS name,\n  CASE WHEN card.id IS NULL THEN wt.status\n    WHEN card.status IN ('done', 'archived') THEN 'done' ELSE 'active' END AS status,\n  CASE WHEN card.id IS NULL THEN wt.milestone_id ELSE card.milestone_id END AS milestone_id,\n  wt.worktree_json, wt.layout_json, wt.cwd, wt.created_at, wt.last_opened_at, wt.layout_revision,\n  card.status AS card_status, wt.rowid AS _created_order\n  FROM workspace_tasks wt LEFT JOIN wand_tasks card ON card.id = (\n    SELECT id FROM wand_tasks WHERE workspace_task_id = wt.id\n    ORDER BY updated_at DESC, rowid DESC LIMIT 1\n  )";
+export type WandTaskPatch = Partial<Pick<WandTask, "workspaceId" | "workspaceTaskId" | "parentTaskId" | "title" | "titleSource" | "autoTitleSignature" | "description" | "status" | "priority" | "labels" | "dueDate" | "milestoneId" | "sortOrder" | "agent" | "executionSubject" | "acceptance" | "verification" | "deliveryRevision">>;
+export declare const WAND_TASK_FIELDS = "id, identifier, workspace_id, workspace_task_id, parent_task_id,\n  title, title_source, auto_title_signature, description, status, priority, labels_json,\n  due_date, milestone_id, sort_order, agent_json, execution_subject_json, archived_at, created_at, updated_at, acceptance_json, verification_json, delivery_revision";
+export declare const WORKSPACE_TASK_PROJECTION = "SELECT wt.id,\n  CASE WHEN card.id IS NULL THEN wt.workspace_id\n    ELSE COALESCE(card.workspace_id, 'wand-global') END AS workspace_id,\n  CASE WHEN card.id IS NULL THEN wt.name ELSE card.title END AS name,\n  CASE WHEN card.id IS NULL THEN wt.status\n    WHEN card.status = 'archived' THEN 'done' ELSE 'active' END AS status,\n  CASE WHEN card.id IS NULL THEN wt.milestone_id ELSE card.milestone_id END AS milestone_id,\n  wt.container_kind, wt.worktree_json, wt.layout_json, wt.cwd, wt.created_at, wt.last_opened_at, wt.layout_revision,\n  card.status AS card_status, wt.rowid AS _created_order\n  FROM workspace_tasks wt LEFT JOIN wand_tasks card ON card.id = (\n    SELECT id FROM wand_tasks WHERE workspace_task_id = wt.id\n    ORDER BY updated_at DESC, rowid DESC LIMIT 1\n  )";
 export declare function withoutSessionTab(node: LayoutNode, sessionId: string): LayoutNode;
 export declare function mapSiliconEmployeeRow(row: Record<string, unknown>): SiliconEmployee;
 export declare function mapAiTeamRow(row: Record<string, unknown>): AiTeam;

package/dist/storage/internal.js

@@ -17,7 +17,7 @@ export function resolveDatabasePath(configPath) {
 }
 export const WAND_TASK_FIELDS = `id, identifier, workspace_id, workspace_task_id, parent_task_id,
   title, title_source, auto_title_signature, description, status, priority, labels_json,
-  due_date, milestone_id, sort_order, agent_json, execution_subject_json, archived_at, created_at, updated_at, acceptance_json`;
+  due_date, milestone_id, sort_order, agent_json, execution_subject_json, archived_at, created_at, updated_at, acceptance_json, verification_json, delivery_revision`;
 // Shared metadata comes from the latest explicitly linked card, including meaningful NULLs.
 // The old container columns remain readable for legacy rows until the startup migration.
 export const WORKSPACE_TASK_PROJECTION = `SELECT wt.id,
@@ -25,9 +25,9 @@ export const WORKSPACE_TASK_PROJECTION = `SELECT wt.id,
     ELSE COALESCE(card.workspace_id, '${GLOBAL_WORKSPACE_ID}') END AS workspace_id,
   CASE WHEN card.id IS NULL THEN wt.name ELSE card.title END AS name,
   CASE WHEN card.id IS NULL THEN wt.status
-    WHEN card.status IN ('done', 'archived') THEN 'done' ELSE 'active' END AS status,
+    WHEN card.status = 'archived' THEN 'done' ELSE 'active' END AS status,
   CASE WHEN card.id IS NULL THEN wt.milestone_id ELSE card.milestone_id END AS milestone_id,
-  wt.worktree_json, wt.layout_json, wt.cwd, wt.created_at, wt.last_opened_at, wt.layout_revision,
+  wt.container_kind, wt.worktree_json, wt.layout_json, wt.cwd, wt.created_at, wt.last_opened_at, wt.layout_revision,
   card.status AS card_status, wt.rowid AS _created_order
   FROM workspace_tasks wt LEFT JOIN wand_tasks card ON card.id = (
     SELECT id FROM wand_tasks WHERE workspace_task_id = wt.id

package/dist/storage/knowledge-repository.d.ts

@@ -7,6 +7,10 @@ export declare class KnowledgeRepository {
     private readonly s;
     constructor(db: DatabaseSync, s: WandStorage);
     knowledgeOwners(): {
+        global: {
+            id: string;
+            name: string;
+        };
         employees: Array<{
             id: string;
             name: string;
@@ -19,6 +23,7 @@ export declare class KnowledgeRepository {
     };
     readKnowledgeLibrary(scope: KnowledgeScope, ownerId: string, query?: string, accessToken?: string): KnowledgeLibrary;
     getKnowledgeDocument(scope: KnowledgeScope, ownerId: string, id: string, accessToken?: string): KnowledgeDocument;
+    syncGlobalKnowledge(): void;
     createKnowledgeDocument(scope: KnowledgeScope, ownerId: string, input: KnowledgeDocumentInput, accessToken?: string): {
         entry: KnowledgeDocument;
         created: boolean;