@co0ontty/wand 4.83.1 → 4.84.0

package/dist/settings-web-access.d.ts

@@ -0,0 +1,15 @@
+import type { Express, RequestHandler } from "express";
+import type { AuthPrincipal } from "./storage.js";
+export declare const SETTINGS_WEB_COOKIE = "wand_settings_access";
+/** A WebView-only proof bound to the existing, live client session, not a new administrator login. */
+export declare class SettingsWebAccess {
+    private readonly key;
+    issue(sessionToken: string): string;
+    accepts(sessionToken: string | undefined, cookieHeader: string | undefined): boolean;
+}
+export declare function registerSettingsWebAccessRoute(app: Express, deps: {
+    requireAuth: RequestHandler;
+    useHttps: boolean;
+    access: SettingsWebAccess;
+    authenticateSession(token: string | undefined): AuthPrincipal | null;
+}): void;

package/dist/settings-web-access.js

@@ -0,0 +1,37 @@
+import crypto from "node:crypto";
+import { principalHasScope, readSessionCookie } from "./auth.js";
+export const SETTINGS_WEB_COOKIE = "wand_settings_access";
+/** A WebView-only proof bound to the existing, live client session, not a new administrator login. */
+export class SettingsWebAccess {
+    key = crypto.randomBytes(32);
+    issue(sessionToken) {
+        return crypto.createHmac("sha256", this.key).update(sessionToken).digest("base64url");
+    }
+    accepts(sessionToken, cookieHeader) {
+        if (!sessionToken || !cookieHeader)
+            return false;
+        const prefix = `${SETTINGS_WEB_COOKIE}=`;
+        const value = cookieHeader.split(";").map((part) => part.trim()).find((part) => part.startsWith(prefix))?.slice(prefix.length);
+        if (!value || !/^[A-Za-z0-9_-]{43}$/.test(value))
+            return false;
+        return crypto.timingSafeEqual(Buffer.from(value), Buffer.from(this.issue(sessionToken)));
+    }
+}
+export function registerSettingsWebAccessRoute(app, deps) {
+    app.post("/api/settings/webview-session", deps.requireAuth, (req, res) => {
+        const token = readSessionCookie(req, deps.useHttps);
+        const principal = deps.authenticateSession(token);
+        if (!token || !principal) {
+            res.status(401).json({ error: "客户端登录已失效，请重新连接客户端。" });
+            return;
+        }
+        if (!principalHasScope(principal, "session-preferences")) {
+            res.status(403).json({ error: "当前客户端连接不能访问完整设置。" });
+            return;
+        }
+        // The parent session remains unchanged; revocation/expiry immediately invalidates this proof.
+        res.set("Cache-Control", "no-store").cookie(SETTINGS_WEB_COOKIE, deps.access.issue(token), {
+            httpOnly: true, sameSite: "strict", secure: deps.useHttps, path: "/", maxAge: 1000 * 60 * 60 * 12,
+        }).json({ ok: true });
+    });
+}

package/dist/silicon-employee-defaults.d.ts

@@ -0,0 +1,29 @@
+import { type ProviderModelField } from "./config.js";
+import type { WandTaskAgent } from "./task-types.js";
+import type { SessionProvider, WandConfig } from "./types.js";
+/**
+ * 员工创建默认执行配置（用户显式保存的那份）。与看板的
+ * `pref:taskBoardLastAgent` 分开：任务默认跟随最近派发，员工默认只跟用户确认过的创建配置。
+ */
+export declare const EMPLOYEE_CREATION_DEFAULTS_PREF = "pref:employeeCreationAgent";
+export type EmployeeDefaultsConfig = Pick<WandConfig, "defaultProvider" | ProviderModelField>;
+export interface SiliconEmployeeDefaults {
+    configured: boolean;
+    /** false 时唯一合法动作是让用户自己选；服务端不替任何端硬编码默认。 */
+    requiresUserChoice: boolean;
+    source?: "saved" | "server";
+    provider?: SessionProvider;
+    /** 新员工将使用的执行候选；与「生成草稿用的系统 AI 模型」是两条独立链路。 */
+    agent?: WandTaskAgent;
+    /** 该 provider 当前生效的服务端默认模型，仅作展示（agent.model 仍是 "default"）。 */
+    defaultModel?: string;
+    reason?: string;
+}
+/**
+ * 两端唯一的默认解析：已保存的员工创建配置 → 服务端 defaultProvider/defaultModel → 需要用户选择。
+ * 纯函数；saved 的解析（parseTaskAgent 等）由调用方完成后传入。
+ */
+export declare function resolveSiliconEmployeeDefaults(input: {
+    savedAgent?: WandTaskAgent | null;
+    config?: EmployeeDefaultsConfig;
+}): SiliconEmployeeDefaults;

package/dist/silicon-employee-defaults.js

@@ -0,0 +1,41 @@
+import { getDefaultModelForProvider } from "./config.js";
+import { employeeAgentFor } from "./silicon-employee-draft.js";
+import { isSessionProvider } from "./session-provider.js";
+/**
+ * 员工创建默认执行配置（用户显式保存的那份）。与看板的
+ * `pref:taskBoardLastAgent` 分开：任务默认跟随最近派发，员工默认只跟用户确认过的创建配置。
+ */
+export const EMPLOYEE_CREATION_DEFAULTS_PREF = "pref:employeeCreationAgent";
+/**
+ * 两端唯一的默认解析：已保存的员工创建配置 → 服务端 defaultProvider/defaultModel → 需要用户选择。
+ * 纯函数；saved 的解析（parseTaskAgent 等）由调用方完成后传入。
+ */
+export function resolveSiliconEmployeeDefaults(input) {
+    const saved = input.savedAgent;
+    if (saved && saved.kind === "structured" && isSessionProvider(saved.provider)) {
+        return {
+            configured: true,
+            requiresUserChoice: false,
+            source: "saved",
+            provider: saved.provider,
+            agent: saved,
+            defaultModel: getDefaultModelForProvider(input.config ?? {}, saved.provider),
+        };
+    }
+    const provider = input.config?.defaultProvider;
+    if (provider && isSessionProvider(provider)) {
+        return {
+            configured: true,
+            requiresUserChoice: false,
+            source: "server",
+            provider,
+            agent: employeeAgentFor(provider),
+            defaultModel: getDefaultModelForProvider(input.config ?? {}, provider),
+        };
+    }
+    return {
+        configured: false,
+        requiresUserChoice: true,
+        reason: "服务端未配置默认执行工具，请在创建员工时自行选择执行配置。",
+    };
+}

package/dist/silicon-employee-dispatch.d.ts

@@ -1,9 +1,13 @@
 import type { SiliconEmployee } from "./ai-team-types.js";
 import type { WandTaskAgent } from "./task-types.js";
+export interface EmployeeCandidateSelectionOptions {
+    /** 普通任务派发只走 CLI；显式员工会话可允许已配置的 SDK。 */
+    skipSdk?: boolean;
+}
 /** Match child-process PATH without starting a shell or trusting a client availability claim. */
 export declare function employeeCliAvailable(agent: WandTaskAgent, pathValue?: string): boolean;
 /** First installed candidate wins; when none is installed retain the preferred candidate for a recoverable failure. */
-export declare function selectEmployeeCandidate(employee: Pick<SiliconEmployee, "agents">, available?: (agent: WandTaskAgent) => boolean): {
+export declare function selectEmployeeCandidate(employee: Pick<SiliconEmployee, "agents">, available?: (agent: WandTaskAgent) => boolean, options?: EmployeeCandidateSelectionOptions): {
     agent: WandTaskAgent;
     index: number;
 };

package/dist/silicon-employee-dispatch.js

@@ -4,10 +4,16 @@ export function employeeCliAvailable(agent, pathValue = process.env.PATH ?? "")
     return providerCliInstalled(agent.provider, pathValue);
 }
 /** First installed candidate wins; when none is installed retain the preferred candidate for a recoverable failure. */
-export function selectEmployeeCandidate(employee, available = employeeCliAvailable) {
-    if (!employee.agents.length || employee.agents.some((agent) => agent.kind !== "structured")) {
+export function selectEmployeeCandidate(employee, available = employeeCliAvailable, options = {}) {
+    const candidates = options.skipSdk ? employee.agents.filter((agent) => agent.engine !== "sdk") : employee.agents;
+    if (!candidates.length)
+        throw new Error("硅基员工没有可用的 CLI 执行候选。");
+    if (!candidates.length || candidates.some((agent) => agent.kind !== "structured")) {
         throw new Error("硅基员工没有可用的结构化执行候选。");
     }
-    const index = employee.agents.findIndex((agent) => available(agent));
-    return { agent: employee.agents[index < 0 ? 0 : index], index: index < 0 ? 0 : index };
+    const index = candidates.findIndex((agent) => available(agent));
+    const selectedIndex = index < 0 ? 0 : index;
+    const agent = candidates[selectedIndex];
+    const originalIndex = employee.agents.indexOf(agent);
+    return { agent, index: originalIndex };
 }

package/dist/silicon-employee-draft.d.ts

@@ -1,11 +1,12 @@
 import { type QuickCommitAiOptions } from "./git-quick-commit.js";
-import type { SiliconEmployeeDraft } from "./ai-team-types.js";
+import { type SiliconEmployeeDraft } from "./ai-team-types.js";
 import type { AiTextRequest } from "./types.js";
 import type { WandTaskAgent } from "./task-types.js";
 import type { SessionProvider } from "./types.js";
 export declare class SiliconEmployeeDraftError extends Error {
     readonly code: string;
-    constructor(message: string, code: string);
+    readonly field?: string | undefined;
+    constructor(message: string, code: string, field?: string | undefined);
 }
 /** 硅基员工只能跑结构化会话；候选沿用看板的「跟随服务端默认」。 */
 export declare function employeeAgentFor(provider: SessionProvider): WandTaskAgent;
@@ -16,14 +17,30 @@ export declare function employeeAgentFor(provider: SessionProvider): WandTaskAge
 export declare function availableEmployeeProviders(preferred?: SessionProvider, isAvailable?: (agent: WandTaskAgent) => boolean): SessionProvider[];
 /** 从模型输出里取第一个 JSON 对象，容忍前后夹带解释文字。 */
 export declare function extractDraftJson(raw: string): Record<string, unknown>;
+export interface EmployeeDraftNormalizeOptions {
+    allowedProviders?: SessionProvider[];
+    fallbackProvider?: SessionProvider;
+    existingNames?: string[];
+    /** 结构化输入（HR 草稿 / API 直传）走严格模式：非法资源直接拒绝，不静默兜底。 */
+    strict?: boolean;
+}
 /**
- * 校验并收敛模型输出。名字 / 角色设定缺失即视为不可用；
- * provider 不在已安装清单里时按候选顺序兜底，不让员工带着跑不起来的 CLI 落库。
+ * 唯一的草稿规范化/校验入口：模型输出与结构化草稿都经过这里。
+ * 名字 / 角色设定缺失即视为不可用；strict=false 时 provider 不在允许集合内按候选顺序兜底，
+ * strict=true 时拒绝并提示选择，避免把非法或越费用边界的资源悄悄换成别的。
+ */
+export declare function normalizeSiliconEmployeeDraft(record: Record<string, unknown>, options?: EmployeeDraftNormalizeOptions): SiliconEmployeeDraft;
+/**
+ * 校验并收敛模型输出（宽松路径：非法 provider 在允许集合内按候选顺序兜底，
+ * 不让员工带着跑不起来的 CLI 落库）。
  */
 export declare function parseSiliconEmployeeDraft(raw: string, options?: {
     allowedProviders?: SessionProvider[];
     fallbackProvider?: SessionProvider;
+    existingNames?: string[];
 }): SiliconEmployeeDraft;
+/** HR / 客户端已给出完整结构化草稿时走同一校验，不再调用模型。 */
+export declare function validateStructuredEmployeeDraft(input: unknown, options?: Omit<EmployeeDraftNormalizeOptions, "strict">): SiliconEmployeeDraft;
 /** 规则走系统提示，用户的期望走用户消息；一次性调用沿用系统 AI 通道。 */
 export declare function buildEmployeeDraftPrompt(expectation: string, providers: SessionProvider[], existingNames?: string[]): AiTextRequest;
 /** 按自然语言期望生成员工配置；调用方负责随后落库。 */

package/dist/silicon-employee-draft.js

@@ -1,13 +1,17 @@
 import { callConfiguredAiText } from "./git-quick-commit.js";
 import { employeeCliAvailable } from "./silicon-employee-dispatch.js";
 import { SESSION_PROVIDERS, isSessionProvider } from "./session-provider.js";
+import { isThinkingEffort } from "./structured-provider-common.js";
 import { DEFAULT_WAND_TASK_AGENT_KIND, DEFAULT_WAND_TASK_AGENT_MODE, normalizeWandTaskAgentMode, } from "./task-types.js";
 import { clipAtWordBoundary } from "./text-utils.js";
+import { agentKey } from "./ai-team-types.js";
 export class SiliconEmployeeDraftError extends Error {
     code;
-    constructor(message, code) {
+    field;
+    constructor(message, code, field) {
         super(message);
         this.code = code;
+        this.field = field;
         this.name = "SiliconEmployeeDraftError";
     }
 }
@@ -79,27 +83,108 @@ function oneLine(record, key) {
     const value = record[key];
     return typeof value === "string" ? value.replace(/\s+/g, " ").trim() : "";
 }
+function stringValue(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
 /**
- * 校验并收敛模型输出。名字 / 角色设定缺失即视为不可用；
- * provider 不在已安装清单里时按候选顺序兜底，不让员工带着跑不起来的 CLI 落库。
+ * 解析一个执行候选。员工候选只允许结构化会话，provider 必须在允许集合内；
+ * 模型只接受字符串（空即 "default"，跟随服务端默认），不静默改成别的资源。
  */
-export function parseSiliconEmployeeDraft(raw, options = {}) {
-    const record = extractDraftJson(raw);
+function parseEmployeeCandidate(raw, allowed) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        throw new SiliconEmployeeDraftError("执行候选必须是对象。", "DRAFT_INVALID_AGENT", "agents");
+    }
+    const body = raw;
+    const provider = stringValue(body.provider).toLowerCase();
+    if (!isSessionProvider(provider)) {
+        throw new SiliconEmployeeDraftError("请选择有效的执行工具。", "DRAFT_INVALID_PROVIDER", "provider");
+    }
+    if (allowed.length && !allowed.includes(provider)) {
+        throw new SiliconEmployeeDraftError(`执行工具「${provider}」不在当前允许的候选集合（${allowed.join("、")}）里，请重新选择。`, "DRAFT_PROVIDER_NOT_ALLOWED", "provider");
+    }
+    const model = stringValue(body.model) || "default";
+    if (model.length > 128) {
+        throw new SiliconEmployeeDraftError("模型名称过长。", "DRAFT_MODEL_TOO_LONG", "model");
+    }
+    const effort = stringValue(body.thinkingEffort) || "off";
+    if (!isThinkingEffort(effort)) {
+        throw new SiliconEmployeeDraftError("思考深度无效。", "DRAFT_INVALID_THINKING", "thinkingEffort");
+    }
+    const engine = stringValue(body.engine);
+    if (engine && engine !== "cli" && engine !== "sdk") {
+        throw new SiliconEmployeeDraftError("执行引擎无效。", "DRAFT_INVALID_ENGINE", "engine");
+    }
+    if (engine === "sdk" && provider !== "pi") {
+        throw new SiliconEmployeeDraftError("SDK 执行引擎仅支持 Pi 结构化会话。", "DRAFT_INVALID_ENGINE", "engine");
+    }
+    return {
+        provider,
+        model,
+        thinkingEffort: effort,
+        mode: normalizeWandTaskAgentMode(provider, body.mode ?? DEFAULT_WAND_TASK_AGENT_MODE),
+        kind: DEFAULT_WAND_TASK_AGENT_KIND,
+        ...(engine === "sdk" ? { engine: "sdk" } : {}),
+    };
+}
+/**
+ * 唯一的草稿规范化/校验入口：模型输出与结构化草稿都经过这里。
+ * 名字 / 角色设定缺失即视为不可用；strict=false 时 provider 不在允许集合内按候选顺序兜底，
+ * strict=true 时拒绝并提示选择，避免把非法或越费用边界的资源悄悄换成别的。
+ */
+export function normalizeSiliconEmployeeDraft(record, options = {}) {
     const name = clipAtWordBoundary(oneLine(record, "name"), NAME_MAX);
     if (!name)
-        throw new SiliconEmployeeDraftError("AI 没有给出员工名字，请重试。", "DRAFT_MISSING_NAME");
+        throw new SiliconEmployeeDraftError("AI 没有给出员工名字，请重试。", "DRAFT_MISSING_NAME", "name");
     const duty = clipAtWordBoundary(oneLine(record, "duty"), DUTY_MAX);
     const prompt = typeof record.prompt === "string" ? record.prompt.trim().slice(0, PROMPT_MAX) : "";
-    if (!prompt)
-        throw new SiliconEmployeeDraftError("AI 没有给出员工角色设定，请重试。", "DRAFT_MISSING_PROMPT");
+    if (!prompt) {
+        throw new SiliconEmployeeDraftError(options.strict ? "员工草稿缺少角色设定。" : "AI 没有给出员工角色设定，请重试。", "DRAFT_MISSING_PROMPT", "prompt");
+    }
+    const duplicate = (options.existingNames ?? []).some((existing) => existing.trim().toLowerCase() === name.toLowerCase());
+    if (duplicate) {
+        throw new SiliconEmployeeDraftError(`已有名叫「${name}」的员工，请换个名字。`, "DRAFT_DUPLICATE_NAME", "name");
+    }
     const allowed = options.allowedProviders?.length ? options.allowedProviders : [...SESSION_PROVIDERS];
-    const requested = oneLine(record, "provider").toLowerCase();
-    const provider = isSessionProvider(requested) && allowed.includes(requested)
-        ? requested
-        : options.fallbackProvider && allowed.includes(options.fallbackProvider)
-            ? options.fallbackProvider
-            : allowed[0];
-    return { name, duty, prompt, agent: employeeAgentFor(provider) };
+    let candidates;
+    if (Array.isArray(record.agents) && record.agents.length > 0) {
+        candidates = record.agents.map((raw) => parseEmployeeCandidate(raw, allowed));
+        if (new Set(candidates.map(agentKey)).size !== candidates.length) {
+            throw new SiliconEmployeeDraftError("执行候选存在重复。", "DRAFT_DUPLICATE_AGENT", "agents");
+        }
+    }
+    else if (record.agent !== undefined && record.agent !== null) {
+        candidates = [parseEmployeeCandidate(record.agent, allowed)];
+    }
+    else if (options.strict) {
+        if (!stringValue(record.provider)) {
+            throw new SiliconEmployeeDraftError("员工草稿缺少执行候选。", "DRAFT_MISSING_AGENT", "provider");
+        }
+        candidates = [parseEmployeeCandidate({ provider: record.provider, model: record.model, thinkingEffort: record.thinkingEffort, mode: record.mode }, allowed)];
+    }
+    else {
+        const requested = oneLine(record, "provider").toLowerCase();
+        const provider = isSessionProvider(requested) && allowed.includes(requested)
+            ? requested
+            : options.fallbackProvider && allowed.includes(options.fallbackProvider)
+                ? options.fallbackProvider
+                : allowed[0];
+        candidates = [employeeAgentFor(provider)];
+    }
+    return { name, duty, prompt, agent: candidates[0], candidates };
+}
+/**
+ * 校验并收敛模型输出（宽松路径：非法 provider 在允许集合内按候选顺序兜底，
+ * 不让员工带着跑不起来的 CLI 落库）。
+ */
+export function parseSiliconEmployeeDraft(raw, options = {}) {
+    return normalizeSiliconEmployeeDraft(extractDraftJson(raw), options);
+}
+/** HR / 客户端已给出完整结构化草稿时走同一校验，不再调用模型。 */
+export function validateStructuredEmployeeDraft(input, options = {}) {
+    if (!input || typeof input !== "object" || Array.isArray(input)) {
+        throw new SiliconEmployeeDraftError("员工草稿必须是对象。", "DRAFT_INVALID_DRAFT");
+    }
+    return normalizeSiliconEmployeeDraft(input, { ...options, strict: true });
 }
 /** 规则走系统提示，用户的期望走用户消息；一次性调用沿用系统 AI 通道。 */
 export function buildEmployeeDraftPrompt(expectation, providers, existingNames = []) {
@@ -133,7 +218,9 @@ export async function generateSiliconEmployeeDraft(expectation, ai = {}, options
     const providers = available.length ? available : [options.preferredProvider ?? "claude", ...SESSION_PROVIDERS];
     const request = buildEmployeeDraftPrompt(trimmed, providers, options.existingNames);
     try {
-        return await callConfiguredAiText(request, options.cwd || process.cwd(), options.language ?? "", ai, (raw) => parseSiliconEmployeeDraft(raw, { allowedProviders: providers, fallbackProvider: providers[0] }));
+        return await callConfiguredAiText(request, options.cwd || process.cwd(), options.language ?? "", ai, (raw) => parseSiliconEmployeeDraft(raw, {
+            allowedProviders: providers, fallbackProvider: providers[0], existingNames: options.existingNames,
+        }));
     }
     catch (error) {
         if (error instanceof SiliconEmployeeDraftError)

package/dist/storage.d.ts

@@ -1,4 +1,6 @@
+import { type ConversationInstance, type ConversationRequest } from "./conversation-types.js";
 import { SessionSnapshot, ConversationTurn, SessionProvider, StructuredSessionState, Workspace, LayoutNode, TaskWindowLayout, WorkspaceDefaultProvider, WorkspaceKind, WorkspaceTask, WorkspaceTaskWorktree, WorkspaceTaskStatus } from "./types.js";
+import { type PiSessionSettings } from "./pi-session-settings.js";
 import type { AiTeam, AiTeamRun, AiTeamRunChatMarker, AiTeamRunStatus, AiTeamStep, AiTeamStepSessionMarker, CandidateFailureKind, SiliconEmployee, StepDispatchInfo } from "./ai-team-types.js";
 import type { WandTask, WandTaskAgent, WandTaskAgentKind, WandTaskTitleSource } from "./task-types.js";
 import { type SystemEmployeeSeed } from "./system-employee.js";
@@ -74,6 +76,43 @@ export declare class WandStorage {
      * be nested because SQLite does not support a second BEGIN on this connection.
      */
     transaction<T>(action: () => T): T;
+    conversationListState(id: string): {
+        pinnedAt: string | null;
+        dissolvedAt: string | null;
+        dissolvedBy: string | null;
+        deleting: boolean;
+    };
+    /** Separate from channel snapshots, so late run saves cannot overwrite lifecycle state. */
+    updateConversationListState(id: string, patch: {
+        pinned?: boolean;
+        dissolved?: boolean;
+        deleting?: boolean;
+        dissolvedBy?: string;
+    }): void;
+    deleteConversation(id: string): void;
+    listConversations(): ConversationInstance[];
+    getConversation(id: string): ConversationInstance | null;
+    getConversationBySession(sessionId: string): ConversationInstance | null;
+    saveConversation(instance: ConversationInstance): void;
+    conversationTasks(id: string): Array<{
+        taskId: string;
+        linkedAt: string;
+    }>;
+    linkConversationTask(conversationId: string, taskId: string, linkedAt: string): void;
+    /** One canonical task/workspace/instance association commit, before any model input. */
+    createConversationTask(instance: ConversationInstance, input: CreateWandTaskInput, accept?: (task: WandTask) => void): WandTask;
+    /** Commit the first accepted fact, identifiers and DM link together, before any execution I/O. */
+    acceptConversationDispatch(instance: ConversationInstance, input: CreateWandTaskInput | {
+        continueTaskId: string;
+    }, request: ConversationRequest, source?: ConversationInstance): WandTask;
+    /** Message + reply + exact session association + receipt are committed before any model input. */
+    acceptConversationSession(instance: ConversationInstance, createSession: () => string, title: string, input: string, request: ConversationRequest): void;
+    conversationSessionIds(id: string): string[];
+    conversationTaskStartup(taskId: string): ConversationRequest["receipt"] | null;
+    appendConversationEvent(id: string, turn: ConversationTurn): void;
+    conversationEvents(id: string): ConversationTurn[];
+    getConversationRequest(id: string): ConversationRequest | null;
+    saveConversationRequest(request: ConversationRequest): void;
     /** Get a config value from database */
     getConfigValue(key: string): string | null;
     /** Set a config value in database */
@@ -86,6 +125,14 @@ export declare class WandStorage {
     setPreference<T>(key: string, value: T | null | undefined): void;
     /** 判断偏好是否在 DB 中存在（区别于值为 null/false/""）。 */
     hasPreference(key: string): boolean;
+    /**
+     * Pi CLI 会话的「上次设置」：用户在任意 Pi 会话里改过设置后，新建会话以它起步，
+     * 不必每开一个会话都重配自动选择 / CodeMode。返回 null 表示沿用出厂默认
+     * （跟随 Pi 自身配置），不是「设置全关」。只存设置字段本身，不含路径、命令或凭据。
+     */
+    getPiSessionDefaults(): PiSessionSettings | null;
+    /** 写入 Pi 会话默认设置；null / undefined 清除，回到出厂默认。 */
+    setPiSessionDefaults(settings: PiSessionSettings | null | undefined): void;
     /**
      * 用户在首页拖动排序后的目录组顺序（服务端偏好，所有客户端共用）。
      * 存的是客户端看到的组 id：真实工作区用 workspace id，合成目录用 `cwd:<规范化路径>`。
@@ -123,8 +170,10 @@ export declare class WandStorage {
     /** 显式更新某会话的工作空间归属（用于创建时绑定）。 */
     getSessionWorkspace(sessionId: string): Pick<SessionSnapshot, "workspaceId" | "workspaceTaskId"> | null;
     setSessionWorkspaceId(sessionId: string, workspaceId: string | null): void;
-    /** Lightweight count of persisted sessions grouped by workspace. */
-    countSessionsByWorkspace(): Map<string, number>;
+    /** Normal workspace counts exclude archived sessions and sessions in archived tasks. */
+    countSessionsByWorkspace(options?: {
+        includeArchived?: boolean;
+    }): Map<string, number>;
     /** Count user-initiated CLI launches (one per session), including archived sessions. */
     countInteractiveSessionsByProvider(): Record<SessionProvider, number>;
     /** Sessions not yet attached to a project. Omits messages/output. */
@@ -190,7 +239,21 @@ export declare class WandStorage {
     updateWandTask(id: string, patch: WandTaskPatch): WandTask | null;
     /** Commit completion archives only the selected completed cards, atomically. */
     archiveCompletedWandTasks(ids: readonly string[]): string[];
+    /**
+     * Archive the given cards. Already-archived ids are skipped.
+     * `completedOnly` keeps the historical commit helper from closing in-progress work.
+     */
+    archiveWandTasks(ids: readonly string[], options?: {
+        completedOnly?: boolean;
+    }): string[];
     deleteWandTask(id: string): void;
+    /**
+     * 批量硬删除卡片：一次事务，返回实际删除的 id（不存在或已消失的跳过）。
+     * 归档目录的「清空」和保留期扫描都走这里，调用方自己决定哪些 id 可以删。
+     */
+    deleteWandTasks(ids: readonly string[]): string[];
+    /** Single-card hard delete body; callers own the transaction (SQLite forbids nesting). */
+    private removeWandTaskRow;
     /** One-time id-based reconciliation; normal reads never create tasks or repair membership. */
     private migrateTaskRecords;
     /**
@@ -349,6 +412,12 @@ export declare class WandStorage {
     issueDecisionAccess(sessionId: string, now?: number): string;
     resolveDecisionAccess(token: string, now?: number): string | null;
     revokeDecisionAccess(token: string): void;
+    /** CLI-only free inference scope, durable across Server restarts but not reusable by another run. */
+    issueOpenRouterFreeAccess(sessionId: string, selector: string, credentialHash: string, requirements: {
+        preferReasoning?: boolean;
+        allowedSelectors?: readonly string[];
+    }, now?: number): string;
+    revokeOpenRouterFreeAccess(token: string): void;
     /** No IO on input hot paths; queued observations still CAS against the database before writing. */
     userMemoryCaptureState(): Readonly<{
         enabled: boolean;
@@ -374,6 +443,8 @@ export declare class WandStorage {
     saveAiTeam(team: AiTeam): void;
     /** 只删团队定义；已有运行保存了团队快照，不受影响。 */
     deleteAiTeam(id: string): void;
+    /** 保留期清理：删掉一次运行及其步骤。关联会话由调用方按运行所有权删除。 */
+    deleteAiTeamRun(id: string): void;
     saveAiTeamRun(run: AiTeamRun): void;
     /** 群聊会话对应的最近一次运行（同一个群聊可以接着开新运行）。 */
     getLatestAiTeamRunByChat(sessionId: string): AiTeamRun | null;