@co0ontty/wand 4.82.0 → 4.83.1

package/dist/message-truncator.js

@@ -1,6 +1,8 @@
-/** Keep tool payloads out of all chat snapshots and fetch them only when opened. */
+/** Keep full tool payloads out of compact snapshots; retain bounded card previews. */
+import { withToolPreview } from "./tool-preview.js";
 import { createHash } from "node:crypto";
 import { contentHasStructuredImage } from "./structured-content.js";
+import { isDecisionToolCall } from "./decision-tool.js";
 const TRUNCATION_THRESHOLD = 200;
 const SUMMARY_LENGTH = 100;
 /**
@@ -29,21 +31,23 @@ export const MESSAGE_FIRST_PAINT_BYTES = 1024 * 1024;
  * 而不是把整段拉进首屏（窗口的目标是压住首屏载荷，吸附不能反过来把它撑大）。
  */
 const MAX_BLOCK_SNAP_BACK_BYTES = 128 * 1024;
+/** Decision calls keep their raw names; only this local defaults lookup treats them as always visible. */
+function toolNamesForTransport(content) {
+    return new Map(content.flatMap((block) => block.type === "tool_use"
+        ? [[block.id, isDecisionToolCall(block) ? "__wand_decision" : block.name]] : []));
+}
 /** 每个块在客户端是否「默认收起」（思考块 + 默认收起的工具卡片，与传输截断同一口径）。 */
 export function collapsedBlockFlags(content, cardDefaults) {
-    const toolNameById = new Map();
-    for (const block of content) {
-        if (block.type === "tool_use")
-            toolNameById.set(block.id, block.name);
-    }
+    const toolNameById = toolNamesForTransport(content);
     return content.map((block) => {
         switch (block.type) {
             case "thinking":
                 return cardDefaults.thinking !== true;
             case "tool_use":
-                return isToolDefaultCollapsed(block.name, cardDefaults);
+                return !isDecisionToolCall(block) && isToolDefaultCollapsed(block.name, cardDefaults);
             case "tool_result":
-                return isToolDefaultCollapsed(toolNameById.get(block.tool_use_id) ?? "", cardDefaults);
+                return block.semantic?.kind !== "decision"
+                    && isToolDefaultCollapsed(toolNameById.get(block.tool_use_id) ?? "", cardDefaults);
             default:
                 return false;
         }
@@ -75,7 +79,8 @@ function blockTransportBytes(block, cardDefaults, toolNameById) {
         case "tool_result": {
             const result = block;
             const raw = getContentString(result.content);
-            const collapsed = isToolDefaultCollapsed(toolNameById.get(result.tool_use_id) ?? "", cardDefaults);
+            const collapsed = result.semantic?.kind !== "decision"
+                && isToolDefaultCollapsed(toolNameById.get(result.tool_use_id) ?? "", cardDefaults);
             const truncated = collapsed && !result.is_error &&
                 !contentHasStructuredImage(result.content) && raw.length > TRUNCATION_THRESHOLD;
             return truncated ? SUMMARY_LENGTH + 4 : raw.length;
@@ -89,11 +94,7 @@ function blockTransportBytes(block, cardDefaults, toolNameById) {
  * （预算判定只需要知道「超了」，不需要精确值）。
  */
 export function contentTransportBytes(content, cardDefaults, limit = Number.POSITIVE_INFINITY) {
-    const toolNameById = new Map();
-    for (const block of content) {
-        if (block.type === "tool_use")
-            toolNameById.set(block.id, block.name);
-    }
+    const toolNameById = toolNamesForTransport(content);
     let total = 0;
     for (const block of content) {
         total += blockTransportBytes(block, cardDefaults, toolNameById) + 32;
@@ -128,11 +129,7 @@ function cutStartByBudget(content, cardDefaults, visibleBudget, byteBudget) {
     if (content.length === 0)
         return 0;
     const collapsed = collapsedBlockFlags(content, cardDefaults);
-    const toolNameById = new Map();
-    for (const block of content) {
-        if (block.type === "tool_use")
-            toolNameById.set(block.id, block.name);
-    }
+    const toolNameById = toolNamesForTransport(content);
     let visible = 0;
     let bytes = 0;
     let cut = content.length;
@@ -413,11 +410,14 @@ export function compactToolMessagesForTransport(messages, knownToolNames) {
     const toolNameMap = new Map(knownToolNames);
     const imageToolIds = new Set();
     const independentToolIds = new Set();
+    const decisionToolIds = new Set();
     for (const turn of messages) {
         for (const block of turn.content) {
             if (block.type === "tool_use") {
                 toolNameMap.set(block.id, block.name);
-                if (INDEPENDENT_TOOL_NAMES.has(block.name) || block.semantic || block.__subagent
+                if (isDecisionToolCall(block))
+                    decisionToolIds.add(block.id);
+                if (INDEPENDENT_TOOL_NAMES.has(block.name) || block.semantic || isDecisionToolCall(block) || block.__subagent
                     || toolInputShowsImage(block.input ?? {}))
                     independentToolIds.add(block.id);
             }
@@ -427,8 +427,11 @@ export function compactToolMessagesForTransport(messages, knownToolNames) {
         }
     }
     return messages.map((turn) => {
-        const truncatedContent = turn.content.map((block) => {
+        const truncatedContent = turn.content.map(withToolPreview).map((block) => {
             if (block.type === "tool_use") {
+                // 决策卡携带服务端缩略投影（题数/要点/结论），压缩时不能把它降回只有 kind。
+                if (decisionToolIds.has(block.id))
+                    return { ...block, semantic: { ...block.semantic, kind: "decision" }, activity: undefined };
                 if (independentToolIds.has(block.id) || imageToolIds.has(block.id))
                     return block;
                 return {
@@ -442,6 +445,9 @@ export function compactToolMessagesForTransport(messages, knownToolNames) {
                     } : undefined,
                 };
             }
+            if (block.type === "tool_result" && (block.semantic?.kind === "decision" || decisionToolIds.has(block.tool_use_id))) {
+                return { ...block, semantic: { ...block.semantic, kind: "decision" } };
+            }
             if (block.type === "tool_result" && toolNameMap.has(block.tool_use_id)
                 && !INDEPENDENT_TOOL_NAMES.has(toolNameMap.get(block.tool_use_id))
                 && !independentToolIds.has(block.tool_use_id)
@@ -459,6 +465,7 @@ function getContentString(content) {
 }
 /** Existing transport behavior for clients that have not opted into compact tool cards. */
 export function truncateMessagesForTransport(messages, cardDefaults, streamingTurnIndex = -1) {
+    const decisionIds = new Set(messages.flatMap((turn) => turn.content.flatMap((block) => block.type === "tool_use" && isDecisionToolCall(block) ? [block.id] : [])));
     return messages.map((turn, turnIndex) => {
         if (turnIndex === streamingTurnIndex)
             return turn;
@@ -471,7 +478,7 @@ export function truncateMessagesForTransport(messages, cardDefaults, streamingTu
         const truncatedContent = turn.content.map((block) => {
             if (block.type !== "tool_result")
                 return block;
-            if (block.is_error)
+            if (block.is_error || block.semantic?.kind === "decision" || decisionIds.has(block.tool_use_id))
                 return block;
             const toolName = toolNameMap.get(block.tool_use_id) ?? "";
             if (!isToolDefaultCollapsed(toolName, cardDefaults))

package/dist/models.d.ts

@@ -34,6 +34,7 @@ export interface ModelRefreshOptions {
     inheritEnv?: boolean;
     env?: NodeJS.ProcessEnv;
     apiKey?: string;
+    baseUrl?: string;
     commandRunner?: ModelCommandRunner;
     modelsApi?: ClaudeModelsApi;
     verifyClaudeCandidates?: boolean;

package/dist/models.js

@@ -1,5 +1,8 @@
 import { execFile } from "node:child_process";
 import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
 import { promisify } from "node:util";
 import Anthropic from "@anthropic-ai/sdk";
 import { resolveChildEnv } from "./env-utils.js";
@@ -550,18 +553,42 @@ function unionModelEfforts(models) {
     }
     return levels;
 }
-function createOfficialModelsApi(apiKey) {
-    const client = new Anthropic({ apiKey });
+function createOfficialModelsApi(apiKey, baseURL) {
+    const client = new Anthropic({ apiKey, baseURL: baseURL || undefined });
     return {
         list: () => client.models.list({ limit: 100 }),
     };
 }
+function resolveClaudeAuth(options, env) {
+    let apiKey = options.apiKey?.trim() || env.ANTHROPIC_API_KEY?.trim() || env.ANTHROPIC_AUTH_TOKEN?.trim();
+    let baseURL = options.baseUrl?.trim() || env.ANTHROPIC_BASE_URL?.trim();
+    if (!apiKey) {
+        try {
+            const settingsPath = path.join(homedir(), ".claude", "settings.json");
+            if (existsSync(settingsPath)) {
+                const raw = JSON.parse(readFileSync(settingsPath, "utf8"));
+                const token = raw?.env?.ANTHROPIC_AUTH_TOKEN || raw?.env?.ANTHROPIC_API_KEY;
+                if (typeof token === "string" && token.trim()) {
+                    apiKey = token.trim();
+                }
+                const base = raw?.env?.ANTHROPIC_BASE_URL;
+                if (typeof base === "string" && base.trim() && !baseURL) {
+                    baseURL = base.trim();
+                }
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    return { apiKey, baseURL };
+}
 async function listClaudeModelsFromApi(options, env) {
-    const apiKey = options.apiKey?.trim() || env.ANTHROPIC_API_KEY?.trim();
+    const { apiKey, baseURL } = resolveClaudeAuth(options, env);
     if (!apiKey)
         return { ok: false };
     try {
-        const api = options.modelsApi ?? createOfficialModelsApi(apiKey);
+        const api = options.modelsApi ?? createOfficialModelsApi(apiKey, baseURL);
         const models = [];
         for await (const model of api.list()) {
             const id = normalizeClaudeModelId(model?.id);

package/dist/process-manager.d.ts

@@ -3,6 +3,7 @@ import { WandStorage } from "./storage.js";
 import { ExecutionMode, ProcessEventHandler, SessionProvider, SessionSnapshot, SessionSource, WandConfig } from "./types.js";
 import { type PermissionResolution } from "./claude-pty-bridge.js";
 import { type PtyTerminalSnapshot, type PtyHistoryPage } from "./pty-terminal-state.js";
+import { samplePtyForegrounds } from "./pty-foreground.js";
 import { type TerminalHost } from "./terminal-host.js";
 import { type ClaudeHistorySession, type CodexHistorySession, type OpenCodeHistorySession, type QoderHistorySession } from "./provider-history-scanner.js";
 export type { ClaudeHistorySession, CodexHistorySession, OpenCodeHistorySession, QoderHistorySession, } from "./provider-history-scanner.js";
@@ -26,9 +27,18 @@ export declare class PtyInputDeliveryError extends Error {
  * Matches the bridge's own idle-probe delay so both paths make the same call.
  */
 export declare const PTY_TURN_IDLE_MS = 3000;
+/**
+ * 采样间隔：多久向内核问一次「这个 PTY 的前台进程组还是 CLI 吗」。
+ * 只查运行中的 PTY 会话，一次 `ps` 拿全部会话，开销与间隔同量级（毫秒）。
+ */
+export declare const PTY_FOREGROUND_SAMPLE_MS = 1000;
 export interface ProcessManagerOptions {
     /** Overrides the non-Claude PTY turn quiet window (tests use a short one). */
     ptyTurnIdleMs?: number;
+    /** Overrides the foreground-process-group sampling interval (tests use a short one). */
+    ptyForegroundSampleMs?: number;
+    /** Overrides the foreground probe itself, so tests can drive it deterministically. */
+    samplePtyForegrounds?: typeof samplePtyForegrounds;
 }
 export declare class ProcessManager extends EventEmitter {
     private readonly config;
@@ -38,8 +48,16 @@ export declare class ProcessManager extends EventEmitter {
     private readonly providerHistory;
     /** Quiet window for the non-Claude PTY turn tracker. */
     private readonly ptyTurnIdleMs;
+    /** Foreground-process-group sampling interval. */
+    private readonly ptyForegroundSampleMs;
+    /** Foreground probe; injectable so tests can drive it without a real process table. */
+    private readonly probePtyForegrounds;
     /** 24h archive scan timer */
     private archiveTimer;
+    /** 前台进程组采样定时器（见 samplePtyForegrounds） */
+    private ptyForegroundTimer;
+    /** 采样是 async 的，避免慢 ps 重叠成多个进程 */
+    private ptyForegroundSampling;
     /** Per-session debounce timers for throttled persist calls */
     private readonly persistDebounceTimers;
     /** Last persisted message state per session — used to skip redundant message writes */
@@ -53,9 +71,25 @@ export declare class ProcessManager extends EventEmitter {
     private disposed;
     private readonly terminalHost;
     constructor(config: WandConfig, storage: WandStorage, configDir?: string, terminalHost?: TerminalHost, options?: ProcessManagerOptions);
+    /**
+     * 采样每个运行中 PTY 会话的终端前台进程组，得出「CLI 是否还在前台」。
+     *
+     * 这是 ptyBusy 的实时资格判断，取代一次性启动标记：CLI 退出后又被重新拉起
+     * （自更新、手动重跑）时，前台进程组会自然回到 CLI，于是新一轮仍然能被跟踪。
+     * 采样不到（不支持的平台、ps 失败、pid 已消失）就保持上次结论，绝不因此清状态。
+     */
+    private samplePtyForegrounds;
     private makeRestoredRecord;
     private bindRestoredTerminal;
     private initializeClaudeBridge;
+    /**
+     * 这一轮的终端是否值得跟踪：这个会话有 provider CLI，且它现在就在前台
+     * （实时采样的内核事实）；采样不可用时退回一次性的 providerCliActive 标记。
+     *
+     * 纯 shell 会话（没有 provider）不跟踪：用户在终端里随手敲一条命令不应该
+     * 把任务标成「运行中 / 刚完成」。
+     */
+    private canTrackPtyTurn;
     /**
      * Open a non-Claude PTY turn and start its quiet-window timer. Claude's bridge
      * owns ptyBusy, so bridged sessions are left untouched.
@@ -93,7 +127,7 @@ export declare class ProcessManager extends EventEmitter {
         workspaceTaskId?: string;
         interactiveShell?: boolean;
         systemPrompt?: string;
-    }): Promise<SessionSnapshot>;
+    } & Pick<SessionSnapshot, "employeeId" | "employeeName" | "employeeAvatar">): Promise<SessionSnapshot>;
     list(): SessionSnapshot[];
     /** Return lightweight snapshots for the session list (no output/messages). */
     listSlim(): SessionSnapshot[];
@@ -123,6 +157,10 @@ export declare class ProcessManager extends EventEmitter {
      * the PTY so Claude Code switches on the fly.
      */
     setSessionModel(id: string, model: string | null): SessionSnapshot;
+    /**
+     * 归档 / 取消归档一个 PTY 会话：只写标记，不杀进程；保留期清理再按 archivedAt 删除。
+     */
+    setSessionArchived(id: string, archived: boolean): SessionSnapshot;
     /**
      * Set the thinking-effort level for a PTY session. Interactive Claude supports
      * this through /effort; off maps to auto, which restores the model default.

package/dist/process-manager.js

@@ -22,8 +22,10 @@ import { describePtySpawnFailure } from "./ensure-node-pty-helper.js";
 import { resolveSessionProvider, resolveSystemAiContext } from "./session-ai-context.js";
 import { resolveSessionCwd } from "./session-cwd.js";
 import { inferProviderFromCommand } 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";
 import { buildPtyShellLaunchPlan, PtyCliExitMarker } from "./pty-shell-launch.js";
 import { InProcessTerminalHost, } from "./terminal-host.js";
 import { ProviderHistoryScanner, } from "./provider-history-scanner.js";
@@ -480,7 +482,8 @@ function restoreTerminalState(state) {
     return terminal;
 }
 const MAX_SESSIONS = 200;
-const ARCHIVE_AFTER_MS = 1000 * 60 * 60 * 24;
+// 与会话/任务的统一保留期一致：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
@@ -488,6 +491,11 @@ const CONFIRM_WINDOW_SIZE = 800;
  * Matches the bridge's own idle-probe delay so both paths make the same call.
  */
 export const PTY_TURN_IDLE_MS = 3000;
+/**
+ * 采样间隔：多久向内核问一次「这个 PTY 的前台进程组还是 CLI 吗」。
+ * 只查运行中的 PTY 会话，一次 `ps` 拿全部会话，开销与间隔同量级（毫秒）。
+ */
+export const PTY_FOREGROUND_SAMPLE_MS = 1000;
 const UUID_V4_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function getClaudeProjectDir(cwd) {
     // Claude Code encodes the project dir by replacing every non-alphanumeric
@@ -546,8 +554,16 @@ export class ProcessManager extends EventEmitter {
     providerHistory = new ProviderHistoryScanner();
     /** Quiet window for the non-Claude PTY turn tracker. */
     ptyTurnIdleMs;
+    /** Foreground-process-group sampling interval. */
+    ptyForegroundSampleMs;
+    /** Foreground probe; injectable so tests can drive it without a real process table. */
+    probePtyForegrounds;
     /** 24h archive scan timer */
     archiveTimer = null;
+    /** 前台进程组采样定时器（见 samplePtyForegrounds） */
+    ptyForegroundTimer = null;
+    /** 采样是 async 的，避免慢 ps 重叠成多个进程 */
+    ptyForegroundSampling = false;
     /** Per-session debounce timers for throttled persist calls */
     persistDebounceTimers = new Map();
     /** Last persisted message state per session — used to skip redundant message writes */
@@ -565,6 +581,8 @@ export class ProcessManager extends EventEmitter {
         this.config = config;
         this.storage = storage;
         this.ptyTurnIdleMs = options.ptyTurnIdleMs ?? PTY_TURN_IDLE_MS;
+        this.ptyForegroundSampleMs = options.ptyForegroundSampleMs ?? PTY_FOREGROUND_SAMPLE_MS;
+        this.probePtyForegrounds = options.samplePtyForegrounds ?? samplePtyForegrounds;
         this.terminalHost = terminalHost ?? new InProcessTerminalHost();
         this.logger = new SessionLogger(configDir || path.join(process.env.HOME || process.cwd(), ".wand"), config.shortcutLogMaxBytes);
         let startupCodexHistory = null;
@@ -675,6 +693,49 @@ export class ProcessManager extends EventEmitter {
             }
         }, 60 * 1000);
         this.archiveTimer.unref?.();
+        this.ptyForegroundTimer = setInterval(() => { void this.samplePtyForegrounds(); }, this.ptyForegroundSampleMs);
+        this.ptyForegroundTimer.unref?.();
+    }
+    /**
+     * 采样每个运行中 PTY 会话的终端前台进程组，得出「CLI 是否还在前台」。
+     *
+     * 这是 ptyBusy 的实时资格判断，取代一次性启动标记：CLI 退出后又被重新拉起
+     * （自更新、手动重跑）时，前台进程组会自然回到 CLI，于是新一轮仍然能被跟踪。
+     * 采样不到（不支持的平台、ps 失败、pid 已消失）就保持上次结论，绝不因此清状态。
+     */
+    async samplePtyForegrounds() {
+        if (this.disposed || this.ptyForegroundSampling)
+            return;
+        const candidates = [...this.sessions.values()].filter((record) => (record.status === "running"
+            && record.ptyProcess !== null
+            && !record.ptyBridge
+            && typeof record.processId === "number"
+            && record.processId > 0));
+        if (candidates.length === 0)
+            return;
+        this.ptyForegroundSampling = true;
+        try {
+            const samples = await this.probePtyForegrounds(candidates.map((record) => record.processId));
+            if (!samples || this.disposed)
+                return;
+            for (const record of candidates) {
+                if (this.sessions.get(record.id) !== record)
+                    continue;
+                const next = samples.get(record.processId);
+                if (next === undefined || record.ptyForeground === next)
+                    continue;
+                record.ptyForeground = next;
+                // CLI 退回提示符：这一轮立刻结束，不必再等静默窗口。
+                if (!next)
+                    this.closePtyTurn(record);
+            }
+        }
+        catch {
+            // 探测失败只意味着这一轮没有新信息，保留上次结论。
+        }
+        finally {
+            this.ptyForegroundSampling = false;
+        }
     }
     makeRestoredRecord(snapshot, provider, ptyProcess, terminal, history) {
         return {
@@ -756,12 +817,25 @@ export class ProcessManager extends EventEmitter {
             this.handleBridgeEvent(record, event);
         });
     }
+    /**
+     * 这一轮的终端是否值得跟踪：这个会话有 provider CLI，且它现在就在前台
+     * （实时采样的内核事实）；采样不可用时退回一次性的 providerCliActive 标记。
+     *
+     * 纯 shell 会话（没有 provider）不跟踪：用户在终端里随手敲一条命令不应该
+     * 把任务标成「运行中 / 刚完成」。
+     */
+    canTrackPtyTurn(record) {
+        if (record.ptyForeground !== undefined) {
+            return record.ptyForeground && record.provider !== undefined;
+        }
+        return record.providerCliActive;
+    }
     /**
      * Open a non-Claude PTY turn and start its quiet-window timer. Claude's bridge
      * owns ptyBusy, so bridged sessions are left untouched.
      */
     openPtyTurn(record) {
-        if (record.ptyBridge || !record.providerCliActive || record.status !== "running")
+        if (record.ptyBridge || !this.canTrackPtyTurn(record) || record.status !== "running")
             return;
         if (record.ptyBusy !== true) {
             record.ptyBusy = true;
@@ -771,7 +845,7 @@ export class ProcessManager extends EventEmitter {
     }
     /** Extend the quiet window because the CLI is still producing output. */
     refreshPtyTurn(record) {
-        if (record.ptyBridge || !record.providerCliActive)
+        if (record.ptyBridge || !this.canTrackPtyTurn(record))
             return;
         if (record.ptyTurnTimer)
             clearTimeout(record.ptyTurnTimer);
@@ -937,10 +1011,16 @@ export class ProcessManager extends EventEmitter {
         if (chunk && current.providerCliActive && current.autoApprovePermissions && !current.ptyBridge && current.provider === "claude") {
             this.autoConfirmWithRecord(current, chunk, child);
         }
-        // Non-Claude CLIs have no parsed turn boundary; any output while a turn is
-        // open keeps it open (see pty-turn-activity.ts).
-        if (chunk && current.ptyBusy === true)
-            this.refreshPtyTurn(current);
+        // Non-Claude CLIs have no parsed turn boundary: output keeps an open turn
+        // open, and output while the CLI is in the foreground opens one — the CLI may
+        // have (re)started in this terminal long after the one-shot launch marker was
+        // consumed (see pty-turn-activity.ts / pty-foreground.ts).
+        if (chunk && this.canTrackPtyTurn(current)) {
+            if (current.ptyBusy === true)
+                this.refreshPtyTurn(current);
+            else
+                this.openPtyTurn(current);
+        }
         if (chunk)
             onVisibleChunk?.(chunk);
         if (boundary.exitCode !== null)
@@ -963,6 +1043,10 @@ export class ProcessManager extends EventEmitter {
             clearInterval(this.archiveTimer);
             this.archiveTimer = null;
         }
+        if (this.ptyForegroundTimer) {
+            clearInterval(this.ptyForegroundTimer);
+            this.ptyForegroundTimer = null;
+        }
         const pendingPersistIds = new Set(this.persistDebounceTimers.keys());
         for (const timer of this.persistDebounceTimers.values())
             clearTimeout(timer);
@@ -1061,6 +1145,7 @@ export class ProcessManager extends EventEmitter {
         let inheritedAutomationId;
         let inheritedWorkspaceId;
         let inheritedWorkspaceTaskId;
+        let inheritedRole;
         if (opts?.reuseId) {
             const oldRecord = this.sessions.get(id);
             if (oldRecord) {
@@ -1069,6 +1154,7 @@ export class ProcessManager extends EventEmitter {
                 inheritedAutomationId = oldRecord.automationId;
                 inheritedWorkspaceId = oldRecord.workspaceId;
                 inheritedWorkspaceTaskId = oldRecord.workspaceTaskId;
+                inheritedRole = oldRecord;
                 this.cleanupRecord(oldRecord);
                 this.sessions.delete(id);
             }
@@ -1079,6 +1165,7 @@ export class ProcessManager extends EventEmitter {
                 inheritedAutomationId = stored?.automationId;
                 inheritedWorkspaceId = stored?.workspaceId;
                 inheritedWorkspaceTaskId = stored?.workspaceTaskId;
+                inheritedRole = stored ?? undefined;
             }
             this.terminalHost.forget(id);
         }
@@ -1095,7 +1182,7 @@ export class ProcessManager extends EventEmitter {
         const initialThinkingEffort = normalizeThinkingEffort(opts?.thinkingEffort);
         let processedCommand = this.processCommandForMode(command, effectiveMode, provider, selectedModel, initialThinkingEffort);
         // 会话级系统提示：provider 有系统提示开关就走开关（PTY 与结构化行为一致），没有就并进首条输入。
-        const systemPrompt = opts?.systemPrompt?.trim() || undefined;
+        const systemPrompt = (opts?.systemPrompt ?? inheritedRole?.systemPrompt)?.trim() || undefined;
         const initialInputText = initialInput && systemPrompt && !systemPromptFlag(provider)
             ? composeSystemFallback(systemPrompt, initialInput)
             : initialInput;
@@ -1136,6 +1223,9 @@ export class ProcessManager extends EventEmitter {
             sessionSource: opts?.sessionSource ?? inheritedSessionSource ?? "interactive",
             automationId: opts?.automationId ?? inheritedAutomationId,
             systemPrompt: systemPrompt ?? null,
+            employeeId: opts?.employeeId ?? inheritedRole?.employeeId,
+            employeeName: opts?.employeeName ?? inheritedRole?.employeeName,
+            employeeAvatar: opts?.employeeAvatar ?? inheritedRole?.employeeAvatar,
             workspaceId: opts?.workspaceId ?? inheritedWorkspaceId,
             workspaceTaskId: opts?.workspaceTaskId ?? inheritedWorkspaceTaskId,
             provider,
@@ -1549,6 +1639,17 @@ export class ProcessManager extends EventEmitter {
         this.emitEvent({ type: "status", sessionId: id, data: { selectedModel: normalized } });
         return this.snapshot(record);
     }
+    /**
+     * 归档 / 取消归档一个 PTY 会话：只写标记，不杀进程；保留期清理再按 archivedAt 删除。
+     */
+    setSessionArchived(id, archived) {
+        const record = this.mustGet(id);
+        record.archived = archived;
+        record.archivedAt = archived ? new Date().toISOString() : null;
+        this.persist(record);
+        this.emitEvent({ type: "status", sessionId: id, data: { archived, archivedAt: record.archivedAt } });
+        return this.snapshot(record);
+    }
     /**
      * Set the thinking-effort level for a PTY session. Interactive Claude supports
      * this through /effort; off maps to auto, which restores the model default.
@@ -1972,6 +2073,9 @@ export class ProcessManager extends EventEmitter {
             automationId: record.automationId,
             // 会话级系统提示要跟着快照回库（persist 就是走 snapshot），否则重启后 resume 会丢掉角色与规则。
             systemPrompt: record.systemPrompt ?? null,
+            employeeId: record.employeeId,
+            employeeName: record.employeeName,
+            employeeAvatar: record.employeeAvatar,
             provider: record.provider,
             providerCliActive: record.providerCliActive,
             providerCliExitCode: record.providerCliExitCode,

package/dist/provider-catalog.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Provider 的唯一真源：受支持的 CLI 列表、展示名、别名表与推断规则。
+ *
+ * 这个模块必须保持"纯数据 + 纯函数"，不能 import 任何 `node:*`：
+ * 服务端（`src/session-provider.ts`）与浏览器 bundle（`src/web-ui/provider-identity.ts`）
+ * 都直接复用它，避免同一个 provider 概念散落在两处各写一份。
+ */
+/** 全部受支持的会话 provider；顺序即 UI / 派发选择器里的展示顺序。 */
+export declare const SESSION_PROVIDERS: readonly ["claude", "codex", "opencode", "grok", "qoder", "pi", "gemini"];
+export type SessionProvider = (typeof SESSION_PROVIDERS)[number];
+/**
+ * 拥有原生思考档位（`provider:level`）的 provider。
+ * Gemini CLI 没有档位开关，所以不出现在这里：`gemini:max` 这种值不应该被当成合法档位保留。
+ */
+export declare const NATIVE_THINKING_EFFORT_PROVIDERS: readonly ["claude", "codex", "opencode", "grok", "qoder", "pi"];
+/** 原生思考档位的 `provider:level` 形状；各端必须共用同一张 provider 名单。 */
+export declare const NATIVE_THINKING_EFFORT_PATTERN: string;
+/** 判断字符串是否为 `provider:level` 形状的原生思考档。 */
+export declare function isNativeThinkingEffort(value: unknown): boolean;
+/** 运行时守卫：把配置、数据库、请求体里的任意值收敛成 SessionProvider。 */
+export declare function isSessionProvider(value: unknown): value is SessionProvider;
+/** provider 对应的 CLI 可执行文件名（Qoder 的 CLI 叫 qodercli）。 */
+export declare function providerCliCommand(provider: SessionProvider): string;
+/** provider 的展示名。缺省不认识的字符串一律回落到 "AI"。 */
+export declare const PROVIDER_LABELS: Readonly<Record<SessionProvider, string>>;
+/**
+ * provider id 别名表：既接受用户/客户端可能写出的别名（`anthropic`、`open-code`），
+ * 也接受历史 runner 名（`claude-cli-print`、`codex-cli-exec` …），
+ * 供 `normalizeProviderId` 与 `inferProviderFromRunner` 共用。
+ */
+export declare const PROVIDER_ALIASES: Readonly<Record<string, SessionProvider>>;
+/** 归一化一个已持久化的 provider id 或 runner/别名；无法识别时返回 null。 */
+export declare function normalizeProviderId(value: unknown): SessionProvider | null;
+/** 从 runner 名推断 provider；`pty` 等与 provider 无关的 runner 返回 undefined。 */
+export declare function inferProviderFromRunner(runner: unknown): SessionProvider | undefined;
+/**
+ * 从启动命令推断 provider；识别的是命令行里真正的可执行名。
+ *
+ * - `/opt/homebrew/bin/claude --resume abc` → claude
+ * - `open-code run` / `qodercli --print` → opencode / qoder
+ * - `npx claude` / `pnpm dlx codex` → 看包管理器后面的真实 CLI
+ *
+ * 参数与父目录名不能冒充别的 provider（`claude -p codex` 仍是 claude）。
+ */
+export declare function inferProviderFromCommand(command: unknown): SessionProvider | undefined;
+/** 每个 provider 在自由文本里可能出现的写法，用于把命令名收敛成可读标签。 */
+export declare function providerDisplayName(value: unknown): string;