@co0ontty/wand 4.83.1 → 4.84.0

package/dist/server-employee-routes.js

@@ -5,7 +5,11 @@ import { asyncRoute } from "./express-async.js";
 import { bodyObject, sendRouteError, text } from "./server-request.js";
 import { parseTaskAgent } from "./server-task-routes.js";
 import { resolveSystemAiContext } from "./session-ai-context.js";
-import { generateSiliconEmployeeDraft } from "./silicon-employee-draft.js";
+import { employeeCliAvailable } from "./silicon-employee-dispatch.js";
+import { EMPLOYEE_CREATION_DEFAULTS_PREF, resolveSiliconEmployeeDefaults, } from "./silicon-employee-defaults.js";
+import { availableEmployeeProviders, generateSiliconEmployeeDraft, SiliconEmployeeDraftError, validateStructuredEmployeeDraft, } from "./silicon-employee-draft.js";
+import { SESSION_PROVIDERS } from "./session-provider.js";
+import { DEFAULT_WAND_TASK_AGENT_KIND } from "./task-types.js";
 import { EMPLOYEE_KNOWLEDGE_MAX_ENTRIES } from "./employee-knowledge-types.js";
 /** 员工起草没有会话上下文，按「默认 provider」解析，与任务标题 / 提示词优化一致。 */
 function employeeDraftAiOptions(storage, config) {
@@ -21,10 +25,22 @@ function employeeDraftAiOptions(storage, config) {
         thinkingEffort: config.defaultThinkingEffort,
     }, config, storage.getSystemSiliconEmployee());
 }
-function sendEmployeeError(res, error) {
+function sendEmployeeError(res, error, context) {
     const message = getErrorMessage(error, "硅基员工操作失败。");
     const status = /不存在/.test(message) ? 404 : 400;
-    sendRouteError(res, error, "硅基员工操作失败。", status);
+    const code = error instanceof SiliconEmployeeDraftError ? error.code : undefined;
+    const field = error instanceof SiliconEmployeeDraftError ? error.field : undefined;
+    if (!code && !context?.expectation) {
+        sendRouteError(res, error, "硅基员工操作失败。", status);
+        return;
+    }
+    // 结构化可恢复错误：带 code/field，并回显原口语输入，客户端可继续编辑重试。
+    res.status(status).json({
+        error: message,
+        ...(code ? { code } : {}),
+        ...(field ? { field } : {}),
+        ...(context?.expectation ? { expectation: context.expectation } : {}),
+    });
 }
 /** 内置员工是 Wand 自己的执行者，不能被归档或删除。 */
 function rejectSystemEmployeeMutation(existing, action) {
@@ -82,7 +98,7 @@ export function parseSystemEmployeeAgents(value, existing) {
         throw new Error("该员工是内置的，身份不可修改。");
     }
     if (!Array.isArray(body.agents))
-        throw new Error("请提供执行候选数组。");
+        throw new Error("请提供执行候选数组（CLI / SDK）。");
     if (body.agents.length === 0)
         throw new Error("至少需要一个执行候选。");
     if (body.agents.length > AI_TEAM_MAX_CANDIDATES) {
@@ -91,7 +107,7 @@ export function parseSystemEmployeeAgents(value, existing) {
     const agents = body.agents.map((rawAgent) => {
         const parsed = parseTaskAgent(rawAgent ?? {});
         if (!parsed)
-            throw new Error("请选择有效的 CLI 工具。");
+            throw new Error("请选择有效的 CLI 工具或 SDK 执行引擎。");
         if (parsed.kind !== "structured")
             throw new Error("硅基员工只支持结构化会话。");
         return parsed;
@@ -120,7 +136,7 @@ export function parseSiliconEmployeeInput(value, existing, now) {
         agents = body.agents.map((rawAgent) => {
             const parsed = parseTaskAgent(rawAgent ?? {});
             if (!parsed)
-                throw new Error("请选择有效的 CLI 工具。");
+                throw new Error("请选择有效的 CLI 工具或 SDK 执行引擎。");
             if (parsed.kind !== "structured")
                 throw new Error("硅基员工只支持结构化会话。");
             return parsed;
@@ -132,7 +148,7 @@ export function parseSiliconEmployeeInput(value, existing, now) {
     else if (body.agent !== undefined && body.agent !== null) {
         const singleAgent = parseTaskAgent(body.agent);
         if (!singleAgent)
-            throw new Error("请选择有效的 CLI 工具。");
+            throw new Error("请选择有效的 CLI 工具或 SDK 执行引擎。");
         if (singleAgent.kind !== "structured")
             throw new Error("硅基员工只支持结构化会话。");
         agents = [singleAgent];
@@ -162,11 +178,31 @@ export function parseSiliconEmployeeInput(value, existing, now) {
 }
 export function registerSiliconEmployeeRoutes(app, deps) {
     const { storage, notifyEmployeeChanged, config } = deps;
+    const isProviderAvailable = deps.isProviderAvailable ?? employeeCliAvailable;
+    /** 已保存的员工创建配置优先；没有就用服务端 defaultProvider；再没有就要求用户选择。 */
+    const savedEmployeeAgent = () => {
+        const raw = storage.getPreference(EMPLOYEE_CREATION_DEFAULTS_PREF, null);
+        if (!raw)
+            return null;
+        try {
+            const agent = parseTaskAgent(raw, undefined, DEFAULT_WAND_TASK_AGENT_KIND);
+            return agent?.kind === "structured" ? agent : null;
+        }
+        catch {
+            return null;
+        }
+    };
+    const resolveDefaults = () => resolveSiliconEmployeeDefaults({ savedAgent: savedEmployeeAgent(), config });
+    const allowedProviders = () => {
+        const available = availableEmployeeProviders(resolveDefaults().provider, isProviderAvailable);
+        return available.length ? available : [...SESSION_PROVIDERS];
+    };
     const generateDraft = deps.generateDraft ?? ((request) => generateSiliconEmployeeDraft(request.expectation, employeeDraftAiOptions(storage, config), {
         cwd: config?.defaultCwd || process.cwd(),
         language: config?.language ?? "",
         existingNames: request.existingNames,
-        preferredProvider: config?.defaultProvider ?? "claude",
+        preferredProvider: resolveDefaults().provider,
+        isProviderAvailable,
     }));
     const notifyEmployee = (employeeId) => {
         try {
@@ -186,17 +222,55 @@ export function registerSiliconEmployeeRoutes(app, deps) {
             sendEmployeeError(res, error);
         }
     });
+    /** 两端唯一的默认执行配置读取点；未配置时如实返回需要用户选择。 */
+    app.get("/api/silicon-employees/draft/defaults", (_req, res) => {
+        res.json(resolveDefaults());
+    });
+    /** 显式保存员工创建默认配置（只落偏好，不创建员工实体）。 */
+    app.put("/api/silicon-employees/draft/defaults", (req, res) => {
+        try {
+            const agent = parseTaskAgent(req.body ?? {}, undefined, DEFAULT_WAND_TASK_AGENT_KIND);
+            if (!agent)
+                throw new Error("请选择有效的执行候选。");
+            if (agent.kind !== "structured")
+                throw new Error("硅基员工只支持结构化会话。");
+            storage.setPreference(EMPLOYEE_CREATION_DEFAULTS_PREF, {
+                provider: agent.provider,
+                model: agent.model,
+                thinkingEffort: agent.thinkingEffort,
+                mode: agent.mode,
+                kind: agent.kind,
+                ...(agent.engine ? { engine: agent.engine } : {}),
+            });
+            res.json(resolveDefaults());
+        }
+        catch (error) {
+            sendEmployeeError(res, error);
+        }
+    });
     app.post("/api/silicon-employees/draft", asyncRoute(async (req, res) => {
+        let expectation = "";
         try {
             const body = bodyObject(req.body);
-            const expectation = text(body.expectation);
+            expectation = text(body.expectation);
             const existingNames = storage.listSiliconEmployees({ includeArchived: true })
                 .map((employee) => employee.name);
+            // HR 已给完整结构化草稿：走同一校验，不再调用模型。
+            if (body.draft !== undefined && body.draft !== null) {
+                const draft = validateStructuredEmployeeDraft(body.draft, {
+                    allowedProviders: allowedProviders(), existingNames,
+                });
+                res.json({ draft, usage: { generateCalls: 0, path: "validated" } });
+                return;
+            }
+            if (!expectation) {
+                throw new SiliconEmployeeDraftError("先说说你对这位员工的期望吧。", "EMPTY_EXPECTATION", "expectation");
+            }
             const draft = await generateDraft({ expectation, existingNames });
-            res.json({ draft });
+            res.json({ draft, usage: { generateCalls: 1, path: "generated" } });
         }
         catch (error) {
-            sendEmployeeError(res, error);
+            sendEmployeeError(res, error, { expectation });
         }
     }));
     app.post("/api/silicon-employees", (req, res) => {

package/dist/server-pi-recommendation-routes.d.ts

@@ -0,0 +1,13 @@
+import type { Express } from "express";
+import type { DecisionService } from "./decision-service.js";
+import type { StructuredSessionManager } from "./structured-session-manager.js";
+import type { SessionRegistry } from "./session-registry.js";
+import type { WandConfig } from "./types.js";
+export type PiRecommendationRuntime = Pick<DecisionService, "evaluate" | "status">;
+/** Uses the parent's login + sessions-scope middleware; inference-only tokens cannot enter this route. */
+export declare function registerPiRecommendationRoute(app: Express, deps: {
+    structured: StructuredSessionManager;
+    sessions: SessionRegistry;
+    config: WandConfig;
+    decisions?: PiRecommendationRuntime;
+}): void;

package/dist/server-pi-recommendation-routes.js

@@ -0,0 +1,67 @@
+import { DecisionError } from "./decision-types.js";
+import { discoverPiResources, resolvePiResourceSelection } from "./pi-resource-catalog.js";
+import { parsePiRecommendationRequest, recommendPiResources } from "./pi-resource-recommendation.js";
+/** Uses the parent's login + sessions-scope middleware; inference-only tokens cannot enter this route. */
+export function registerPiRecommendationRoute(app, deps) {
+    const active = new Set();
+    app.post("/api/sessions/:id/pi-settings/recommend", async (req, res) => {
+        const id = req.params.id;
+        const abort = new AbortController();
+        const disconnected = () => { if (!res.writableEnded)
+            abort.abort(); };
+        let timer;
+        let owns = false;
+        res.set("Cache-Control", "no-store");
+        res.once("close", disconnected);
+        try {
+            const owner = deps.sessions.ownerOf(id);
+            if (!owner)
+                throw new DecisionError("NOT_FOUND", "未找到该会话。", 404);
+            if (owner !== "structured" || deps.structured.get(id)?.provider !== "pi") {
+                throw new DecisionError("UNSUPPORTED", "推荐仅适用于 Pi 结构化会话。");
+            }
+            const { settings, resolution } = deps.structured.getPiSettings(id);
+            if (deps.structured.get(id)?.archived || resolution.engine !== "cli") {
+                throw new DecisionError("UNSUPPORTED", "请使用未归档的 Pi CLI 会话进行资源推荐。");
+            }
+            const status = deps.decisions?.status();
+            if (!deps.decisions || !status?.enabled || !status.supported || !status.configured || settings.localDecision === false) {
+                throw new DecisionError("UNAVAILABLE", "本地决策未启用或不可用，原选择未改变。", 503);
+            }
+            const input = parsePiRecommendationRequest(req.body);
+            if (active.has(id))
+                throw new DecisionError("BUSY", "本会话正在推荐，请等待当前请求完成。", 409);
+            active.add(id);
+            owns = true;
+            timer = setTimeout(() => abort.abort(), 15_000);
+            const inventory = await discoverPiResources(deps.config, deps.structured.get(id).cwd);
+            resolvePiResourceSelection(inventory, input.candidates);
+            const result = await recommendPiResources({ ...input, catalog: inventory.catalog,
+                evaluate: (value, caller, signal) => deps.decisions.evaluate(value, caller, signal),
+                caller: `pi-recommend:${id}`, signal: abort.signal });
+            const latest = deps.structured.get(id);
+            if (!latest || latest.archived || latest.provider !== "pi" || latest.piSettings?.localDecision === false
+                || deps.structured.getPiSettings(id).resolution.engine !== "cli") {
+                throw new DecisionError("CANCELLED", "会话已变化，请重新打开设置面板。", 409);
+            }
+            if (abort.signal.aborted)
+                throw new DecisionError("TIMEOUT", "推荐已取消或超时，原选择未改变。", 504);
+            if (!res.destroyed)
+                res.json(result);
+        }
+        catch (error) {
+            if (res.destroyed)
+                return;
+            const failure = error instanceof DecisionError ? error
+                : new DecisionError("RECOMMEND_FAILED", "推荐失败，请重新打开面板核对资源；原选择未改变。", 400);
+            res.status(failure.status).json({ error: failure.message, code: failure.code });
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+            res.off("close", disconnected);
+            if (owns)
+                active.delete(id);
+        }
+    });
+}

package/dist/server-resume-routes.js

@@ -65,7 +65,7 @@ const STRUCTURED_RESUME_SPECS = [
         path: "/api/pi-sessions/:nativeId/resume",
         param: "nativeId",
         spec: {
-            label: "Pi",
+            label: "one 的 Agent",
             provider: "pi",
             runner: "pi-cli-json",
             nativeIdKey: "claudeSessionId",

package/dist/server-session-routes.d.ts

@@ -4,7 +4,8 @@ import { StructuredSessionManager } from "./structured-session-manager.js";
 import { WandStorage } from "./storage.js";
 import { ExecutionMode, ProcessEvent, SessionSnapshot, SessionSource, WandConfig } from "./types.js";
 import { toSessionListItemDTO } from "./session-transport.js";
-import { SessionRegistry } from "./session-registry.js";
+import { type ProviderHistoryDeleter, SessionRegistry } from "./session-registry.js";
+import { type PiRecommendationRuntime } from "./server-pi-recommendation-routes.js";
 import { type SessionDirectoryNode } from "./session-directory-tree.js";
 export declare function parseExecutionMode(value: unknown, fallback: ExecutionMode): ExecutionMode;
 export declare function parseSessionCreationOrigin(body: {
@@ -14,7 +15,7 @@ export declare function parseSessionCreationOrigin(body: {
     sessionSource: SessionSource;
     automationId?: string;
 };
-type SessionDeletionProcesses = Pick<ProcessManager, "get" | "delete" | "deleteClaudeHistoryFiles" | "deleteCodexHistoryFiles" | "deleteOpenCodeHistorySessions" | "deleteQoderHistoryFiles">;
+type SessionDeletionProcesses = Pick<ProcessManager, "get" | "delete"> & ProviderHistoryDeleter;
 type SessionDeletionStructured = Pick<StructuredSessionManager, "get" | "delete">;
 /**
  * A Wand-managed session and its provider-native history represent the same
@@ -45,6 +46,6 @@ export interface SessionDirectoryTreeResponse {
 }
 export declare function buildSessionListPage(sessions: SessionSnapshot[], offset: number, limit: number): SessionListPage;
 export declare function buildSessionDirectoryTree(sessions: SessionSnapshot[], customNames?: ReadonlyMap<string, string>): SessionDirectoryTreeResponse;
-export declare function registerSessionRoutes(app: Express, processes: ProcessManager, structured: StructuredSessionManager, storage: WandStorage, defaultMode: ExecutionMode, config: WandConfig, sessions: SessionRegistry, onSessionCreated?: (cwd: string | undefined | null) => void, onCompletionViewed?: (event: ProcessEvent) => void): void;
+export declare function registerSessionRoutes(app: Express, processes: ProcessManager, structured: StructuredSessionManager, storage: WandStorage, defaultMode: ExecutionMode, config: WandConfig, sessions: SessionRegistry, onSessionCreated?: (cwd: string | undefined | null) => void, onCompletionViewed?: (event: ProcessEvent) => void, decisions?: PiRecommendationRuntime): void;
 export declare function registerClaudeHistoryRoutes(app: Express, processes: ProcessManager, storage: WandStorage): void;
 export {};

package/dist/server-session-routes.js

@@ -2,6 +2,8 @@ import { createHash } from "node:crypto";
 import { PtyInputDeliveryError, SessionInputError } from "./process-manager.js";
 import { getDefaultModelForProvider, isExecutionMode } from "./config.js";
 import { defaultRoleForCli } from "./default-employee.js";
+import { defaultModelGroupSelector } from "./model-groups.js";
+import { inspectPiExecution } from "./pi-execution.js";
 import { alignedBlockStart, blockWindowMessagesForTransport, compactToolMessagesForTransport, sliceTurnBlocksForTransport, truncateMessagesForTransport, visibleBlockCount, windowMessagesForTransport } from "./message-truncator.js";
 import { toSessionDetailDTO, toSessionListItemDTO } from "./session-transport.js";
 import { checkSessionWorktreeMergeabilityAsync, cleanupSessionWorktreeAsync, getWorktreeMergeErrorCode, mergeSessionWorktreeAsync, WorktreeMergeError, } from "./git-worktree.js";
@@ -18,9 +20,13 @@ import { parseBoundedInteger } from "./request-limits.js";
 import { asyncRoute } from "./express-async.js";
 import { sendRouteError } from "./server-request.js";
 import { registerStructuredResumeRoutes } from "./server-resume-routes.js";
-import { addHiddenSessionIds, removeHiddenSessionIds } from "./session-registry.js";
+import { addHiddenSessionIds, deleteProviderNativeHistory, removeHiddenSessionIds } from "./session-registry.js";
 import { enrichStructuredMessages, WAND_PROTOCOL_VERSION } from "./structured-client-protocol.js";
 import { asRecord, isStructuredImagePart } from "./structured-content.js";
+import { installedPiExtensions } from "./pi-extension-resources.js";
+import { registerPiRecommendationRoute } from "./server-pi-recommendation-routes.js";
+import { discoverPiResources, resolvePiResourceSelection } from "./pi-resource-catalog.js";
+import { effectivePiSessionSettings, patchPiSessionSettings } from "./pi-session-settings.js";
 import { buildDirectoryTree, normalizeSessionDirectory, } from "./session-directory-tree.js";
 import { projectCwdForSession, renameWorkspaceDirectory, resolveWorkspaceIdForNewSession, } from "./workspace-binding.js";
 export function parseExecutionMode(value, fallback) {
@@ -138,24 +144,7 @@ export function deleteSessionWithProviderHistory(processes, structured, storage,
         ?? snapshot.structuredState?.provider
         ?? inferProviderFromCommand(snapshot.command)
         ?? "claude";
-    if (provider === "claude") {
-        processes.deleteClaudeHistoryFiles([{
-                claudeSessionId: providerSessionId,
-                cwd: snapshot.cwd,
-            }]);
-    }
-    else if (provider === "codex") {
-        processes.deleteCodexHistoryFiles([providerSessionId]);
-    }
-    else if (provider === "opencode") {
-        processes.deleteOpenCodeHistorySessions([providerSessionId]);
-    }
-    else if (provider === "qoder") {
-        processes.deleteQoderHistoryFiles([providerSessionId]);
-    }
-    else {
-        return;
-    }
+    deleteProviderNativeHistory(processes, provider, providerSessionId, snapshot.cwd);
     // History deletion is intentionally best-effort at the filesystem layer.
     // Keep a tombstone as a fallback for permission errors or process tail writes.
     addHiddenSessionIds(storage, [providerSessionId]);
@@ -320,6 +309,33 @@ async function startResumedPtySession(processes, storage, existingSession, sessi
         workspaceTaskId: existingSession.workspaceTaskId,
     });
 }
+/** 取消归档后，用原来的 Wand 会话 ID 把终端拉起来；有 provider session id 就续接那次对话。 */
+async function restoreArchivedSession(sessions, processes, storage, sessionId, defaultMode) {
+    const existing = sessions.get(sessionId) ?? storage.getSession(sessionId);
+    if (!existing)
+        return null;
+    const cleared = sessions.setArchived(sessionId, false);
+    if (!cleared)
+        return null;
+    if ((existing.sessionKind ?? "pty") !== "pty" || cleared.status === "running")
+        return cleared;
+    const command = existing.command.trim();
+    if (!command)
+        return cleared;
+    const provider = existing.provider ?? inferProviderFromCommand(command) ?? undefined;
+    if (existing.claudeSessionId && provider && isPtyProviderCommand(provider, command)) {
+        return startResumedPtySession(processes, storage, { ...existing, ...cleared }, sessionId, defaultMode, {});
+    }
+    return processes.start(command, existing.cwd, parseExecutionMode(existing.mode, defaultMode), undefined, {
+        reuseId: sessionId,
+        provider,
+        model: existing.selectedModel ?? undefined,
+        thinkingEffort: existing.thinkingEffort ?? undefined,
+        systemPrompt: existing.systemPrompt ?? undefined,
+        workspaceId: existing.workspaceId,
+        workspaceTaskId: existing.workspaceTaskId,
+    });
+}
 function getAutoResumeInitialInput(snapshot, input, view, shortcutKey) {
     if (view === "terminal") {
         const isCodexPty = Boolean(snapshot?.provider === "codex" || /^codex\b/.test(snapshot?.command.trim() ?? ""));
@@ -349,7 +365,8 @@ function canMergeSession(snapshot) {
 function isMergeActionAllowed(snapshot) {
     return snapshot.status !== "running";
 }
-export function registerSessionRoutes(app, processes, structured, storage, defaultMode, config, sessions, onSessionCreated, onCompletionViewed) {
+export function registerSessionRoutes(app, processes, structured, storage, defaultMode, config, sessions, onSessionCreated, onCompletionViewed, decisions) {
+    registerPiRecommendationRoute(app, { structured, sessions, config, decisions });
     const wantsCompactTools = (req) => req.get("X-Wand-Tool-Projection") === "compact" || req.query.compactTools === "1";
     const sessionResponseDTO = (snapshot, req) => {
         const enriched = enrichStructuredMessages(snapshot.messages ?? [], snapshot.id);
@@ -462,11 +479,15 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
                 throw new Error("硅基员工不存在或已归档。");
             const selectedEmployeeCandidate = employee ? selectEmployeeCandidate(employee) : null;
             const employeeAgent = selectedEmployeeCandidate?.agent;
-            if (!employee && body.provider && !isSessionProvider(body.provider)) {
+            if (body.provider && !isSessionProvider(body.provider)) {
                 res.status(400).json({ error: "结构化会话当前仅支持 Claude、Codex、OpenCode、Grok、Qoder、Pi 或 Gemini provider。" });
                 return;
             }
-            const provider = employeeAgent?.provider
+            const overrideCli = body.overrideCli === true;
+            const rawProvider = typeof body.provider === "string" ? body.provider.trim() : "";
+            const requestedProvider = overrideCli && isSessionProvider(rawProvider) ? rawProvider : null;
+            const provider = requestedProvider
+                ?? employeeAgent?.provider
                 ?? (isSessionProvider(body.provider) ? body.provider : config.defaultProvider ?? "claude");
             const rawModel = typeof body.model === "string" ? body.model.trim() : "";
             const origin = parseSessionCreationOrigin(body);
@@ -477,15 +498,19 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
             const cwd = resolveSessionCwd(body.cwd, config.defaultCwd);
             const snapshot = structured.createSession({
                 cwd,
-                mode: employeeAgent?.mode ?? parseExecutionMode(body.mode, defaultMode),
+                mode: (requestedProvider && body.mode ? parseExecutionMode(body.mode, defaultMode) : null)
+                    ?? employeeAgent?.mode
+                    ?? parseExecutionMode(body.mode, defaultMode),
                 provider,
                 // Omit runner to let StructuredSessionManager apply the configured
                 // Claude default; explicit values are validated against the provider.
-                runner: employee ? undefined : body.runner,
+                runner: employee && !requestedProvider ? undefined : body.runner,
                 worktreeEnabled: body.worktreeEnabled === true,
-                model: employeeAgent
-                    ? employeeAgent.model === "default" ? getDefaultModelForProvider(config, provider) || undefined : employeeAgent.model
-                    : rawModel || getDefaultModelForProvider(config, provider) || undefined,
+                model: rawModel && rawModel !== "default"
+                    ? rawModel
+                    : (employeeAgent && !requestedProvider
+                        ? employeeAgent.model === "default" ? defaultModelGroupSelector(config.modelGroups, provider, getDefaultModelForProvider(config, provider)) || getDefaultModelForProvider(config, provider) || undefined : employeeAgent.model
+                        : rawModel || defaultModelGroupSelector(config.modelGroups, provider, getDefaultModelForProvider(config, provider)) || getDefaultModelForProvider(config, provider) || undefined),
                 thinkingEffort: employeeAgent?.thinkingEffort ?? (typeof body.thinkingEffort === "string"
                     ? body.thinkingEffort
                     : config.defaultThinkingEffort),
@@ -497,7 +522,7 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
                 employeeName: role?.name,
                 employeeAvatar: role?.avatar,
                 employeeCandidates: employee?.agents,
-                employeeCandidateIndex: selectedEmployeeCandidate?.index,
+                employeeCandidateIndex: requestedProvider ? undefined : selectedEmployeeCandidate?.index,
                 ...origin,
             });
             onSessionCreated?.(snapshot.cwd);
@@ -553,6 +578,105 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
             sendRouteError(res, error, "切换工具失败。");
         }
     });
+    const piSettingsResponse = async (id) => {
+        const { settings, resolution } = structured.getPiSettings(id);
+        const snapshot = structured.get(id);
+        const installed = await installedPiExtensions(config, snapshot.cwd);
+        const sdk = resolution.engine === "core";
+        const archived = snapshot.archived;
+        const modifiable = !archived;
+        const goalAvailable = installed.some((item) => item.goal);
+        const localDecisionAvailable = config.localDecision?.enabled === true;
+        const inventory = await discoverPiResources(config, snapshot.cwd);
+        const resourceCatalog = { ...inventory.catalog, supported: modifiable && !sdk && inventory.catalog.supported,
+            reason: archived ? "请先恢复已归档的会话。" : sdk ? "当前 SDK 候选尚不支持 Skills / MCP 会话选择。" : inventory.catalog.reason };
+        const controls = {
+            // 基础工具与 CodeMode 在两种引擎下都能表达（CLI 通过 --tools 白名单）。
+            tools: modifiable,
+            codemode: modifiable,
+            codemodeOnly: modifiable && sdk,
+            codemodeOverride: modifiable && !sdk,
+            globalTools: modifiable,
+            goalMode: modifiable && goalAvailable,
+            localDecision: modifiable && localDecisionAvailable,
+            autoCompaction: modifiable && sdk,
+        };
+        const status = decisions?.status();
+        const recommendationAvailable = resourceCatalog.supported && settings.localDecision !== false
+            && status?.enabled === true && status.supported && status.configured;
+        const recommendationReason = !resourceCatalog.supported ? resourceCatalog.reason
+            : settings.localDecision === false ? "本会话已关闭本地决策。"
+                : !recommendationAvailable ? "本地决策未启用或运行环境不可用。" : "";
+        return { recommendationAvailable, recommendationReason,
+            autoResourcesAvailable: recommendationAvailable, autoResourcesReason: recommendationReason,
+            autoCodemodeAvailable: recommendationAvailable, skillLocksAvailable: resourceCatalog.supported,
+            settings: effectivePiSessionSettings(settings, resolution.engine), engine: resolution.engine,
+            available: sdk && modifiable, toolsAvailable: !sdk && modifiable,
+            reason: archived ? "请先恢复已归档的会话。" : resolution.reason,
+            goalAvailable, globalExtensions: [...new Set(installed.filter((item) => !item.goal).map((item) => item.name))],
+            localDecisionAvailable, controls, resourceCatalog };
+    };
+    const requirePiSession = (id) => {
+        const owner = sessions.ownerOf(id);
+        if (!owner)
+            throw Object.assign(new Error("未找到该会话。"), { status: 404 });
+        if (owner !== "structured" || structured.get(id)?.provider !== "pi") {
+            throw new Error("这些设置仅适用于 Pi 结构化会话，不会改变 PTY 或其他工具。");
+        }
+    };
+    app.get("/api/sessions/:id/pi-settings", asyncRoute(async (req, res) => {
+        try {
+            requirePiSession(req.params.id);
+            res.set("Cache-Control", "no-store");
+            res.json(await piSettingsResponse(req.params.id));
+        }
+        catch (error) {
+            sendRouteError(res, error, "读取 Pi 设置失败。", error.status ?? 400);
+        }
+    }));
+    app.patch("/api/sessions/:id/pi-settings", asyncRoute(async (req, res) => {
+        try {
+            const id = req.params.id;
+            requirePiSession(id);
+            const { settings } = structured.getPiSettings(id);
+            const next = patchPiSessionSettings(settings, req.body);
+            if (req.body.autoResources === true) {
+                const capabilities = await piSettingsResponse(id);
+                const runtime = decisions?.status();
+                if (!capabilities.resourceCatalog?.supported || next.localDecision === false
+                    || !runtime?.enabled || !runtime.supported || !runtime.configured) {
+                    throw new Error(next.localDecision === false ? "本会话已关闭本地决策。"
+                        : capabilities.autoResourcesReason || "自动选择暂不可用。");
+                }
+            }
+            if (req.body.resources !== undefined || req.body.lockedSkills !== undefined) {
+                const inventory = await discoverPiResources(config, structured.get(id).cwd);
+                // Removed resources may be retained only when already selected, so users can deselect stale
+                // items one at a time. Any NEW ID must resolve; the runner always revalidates the full list.
+                if (req.body.resources !== undefined)
+                    resolvePiResourceSelection(inventory, {
+                        skills: next.resources.skills.filter((id) => !settings.resources?.skills.includes(id)),
+                        mcpServers: next.resources.mcpServers.filter((id) => !settings.resources?.mcpServers.includes(id)),
+                    });
+                if (req.body.lockedSkills !== undefined)
+                    resolvePiResourceSelection(inventory, {
+                        skills: next.lockedSkills.filter((id) => !settings.lockedSkills?.includes(id)), mcpServers: [],
+                    });
+            }
+            if (next.goalMode && !settings.goalMode) {
+                const installed = await installedPiExtensions(config, structured.get(id).cwd);
+                if (!installed.some((item) => item.goal))
+                    throw new Error("目标模式不可用：请先在 Pi 中安装并启用 pi-goal。");
+            }
+            structured.setPiSettings(id, req.body);
+            // 回复「实际生效」的设置（CLI 的 CodeMode 只归一到 off/on），不把存库原值当生效值展示。
+            const saved = structured.getPiSettings(id);
+            res.json({ settings: effectivePiSessionSettings(saved.settings, saved.resolution.engine) });
+        }
+        catch (error) {
+            sendRouteError(res, error, "保存 Pi 设置失败。", error.status ?? 400);
+        }
+    }));
     app.post("/api/sessions/:id/model", (req, res) => {
         const body = req.body;
         const rawModel = typeof body?.model === "string" ? body.model.trim() : null;
@@ -741,6 +865,20 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
         }
     });
     // ── Tool content lazy-load endpoint ──
+    app.get("/api/sessions/:id/pi-execution/:toolUseId", asyncRoute(async (req, res) => {
+        const snapshot = sessions.get(req.params.id);
+        if (!snapshot) {
+            res.status(404).json({ error: "未找到该会话。" });
+            return;
+        }
+        const execution = await inspectPiExecution(snapshot.messages ?? [], req.params.toolUseId);
+        if (!execution) {
+            res.status(404).json({ error: "未找到该 Pi 执行调用。" });
+            return;
+        }
+        res.setHeader("Cache-Control", "no-store");
+        res.json(execution);
+    }));
     app.get("/api/sessions/:id/tool-content/:toolUseId", (req, res) => {
         const snapshot = sessions.get(req.params.id);
         if (!snapshot) {
@@ -933,7 +1071,10 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
                 try {
                     // A commit is already durable, even when push failed. Archiving must not turn that
                     // successful commit into a retryable HTTP error (which would duplicate the commit).
-                    archivedTaskIds = archiveCommitTasks(storage, snapshot, context.entryIds);
+                    const openedTaskId = typeof body.workspaceTaskId === "string" ? body.workspaceTaskId.trim() : "";
+                    archivedTaskIds = archiveCommitTasks(storage, snapshot, context.entryIds, {
+                        workspaceTaskId: openedTaskId || null,
+                    });
                 }
                 catch (error) {
                     archiveError = getErrorMessage(error, "归档关联任务失败。");
@@ -1379,7 +1520,8 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
         try {
             if (structured.get(sessionId)) {
                 const completion = structured.sendMessage(sessionId, input);
-                if (body.respondImmediately === true) {
+                if (body.respondImmediately === true || (structured.get(sessionId)?.provider === "pi"
+                    && structured.get(sessionId)?.piSettings?.autoResources === true)) {
                     // sendMessage updates the canonical snapshot synchronously before it
                     // starts awaiting the runner. Native clients should not hold this
                     // request open for an entire model turn (which can exceed their HTTP
@@ -1537,7 +1679,7 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
             sendRouteError(res, error, "无法停止会话。");
         }
     });
-    // 归档 / 取消归档会话：只写标记，不杀终端、不删历史；保留期扫描再按 archivedAt 清理。
+    // 归档会停止会话，但保留 Wand 会话 ID 和 provider session id。恢复时用这个 ID 续上。
     app.post("/api/sessions/:id/archive", (req, res) => {
         try {
             const updated = sessions.setArchived(req.params.id, true);
@@ -1551,9 +1693,9 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
             sendRouteError(res, error, "无法归档会话。");
         }
     });
-    app.post("/api/sessions/:id/unarchive", (req, res) => {
+    app.post("/api/sessions/:id/unarchive", asyncRoute(async (req, res) => {
         try {
-            const updated = sessions.setArchived(req.params.id, false);
+            const updated = await restoreArchivedSession(sessions, processes, storage, req.params.id, defaultMode);
             if (!updated) {
                 res.status(404).json({ error: "未找到该会话。" });
                 return;
@@ -1563,9 +1705,9 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
         catch (error) {
             sendRouteError(res, error, "无法恢复会话。");
         }
-    });
+    }));
     // 批量归档 / 恢复：与 /api/sessions/batch-delete 对称，返回失败项让客户端保留选择。
-    app.post("/api/sessions/batch-archive", (req, res) => {
+    app.post("/api/sessions/batch-archive", asyncRoute(async (req, res) => {
         const body = req.body;
         const ids = Array.isArray(body?.sessionIds)
             ? body.sessionIds.filter((value) => typeof value === "string" && value.trim().length > 0)
@@ -1579,7 +1721,10 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
         let changed = 0;
         for (const id of ids) {
             try {
-                if (sessions.setArchived(id, archived))
+                const updated = archived
+                    ? sessions.setArchived(id, true)
+                    : await restoreArchivedSession(sessions, processes, storage, id, defaultMode);
+                if (updated)
                     changed += 1;
                 else
                     failed.push(id);
@@ -1589,7 +1734,7 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
             }
         }
         res.json({ ok: true, archived: changed, ...(failed.length > 0 ? { failed } : {}) });
-    });
+    }));
     app.delete("/api/sessions/:id", (req, res) => {
         try {
             sessions.deleteWithProviderHistory(req.params.id);