@co0ontty/wand 4.81.0 → 4.82.0

package/dist/server-session-routes.js

@@ -1,6 +1,7 @@
 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 { 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";
@@ -463,9 +464,14 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
                 res.status(400).json({ error: "结构化会话当前仅支持 Claude、Codex、OpenCode、Grok、Qoder、Pi 或 Gemini provider。" });
                 return;
             }
-            const provider = employeeAgent?.provider ?? (isSessionProvider(body.provider) ? body.provider : "claude");
+            const provider = employeeAgent?.provider
+                ?? (isSessionProvider(body.provider) ? body.provider : config.defaultProvider ?? "claude");
             const rawModel = typeof body.model === "string" ? body.model.trim() : "";
             const origin = parseSessionCreationOrigin(body);
+            // Explicit employees/custom role rules and internal automation retain their own role.
+            const defaultEmployee = !employee && !body.systemPrompt?.trim()
+                && origin.sessionSource === "interactive" ? defaultRoleForCli(storage, provider) : null;
+            const role = employee ?? defaultEmployee;
             const cwd = resolveSessionCwd(body.cwd, config.defaultCwd);
             const snapshot = structured.createSession({
                 cwd,
@@ -484,10 +490,10 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
                 workspaceId: resolveWorkspaceIdForNewSession(storage, cwd, body.workspaceId),
                 workspaceTaskId: body.workspaceTaskId,
                 // 角色与规则走系统提示通道，不拼进 prompt（见 AGENTS.md「Session 输入契约」）。
-                systemPrompt: employee?.prompt ?? body.systemPrompt,
-                employeeId: employee?.id,
-                employeeName: employee?.name,
-                employeeAvatar: employee?.avatar,
+                systemPrompt: role?.prompt ?? body.systemPrompt,
+                employeeId: role?.id,
+                employeeName: role?.name,
+                employeeAvatar: role?.avatar,
                 employeeCandidates: employee?.agents,
                 employeeCandidateIndex: selectedEmployeeCandidate?.index,
                 ...origin,

package/dist/server-task-routes.js

@@ -9,6 +9,7 @@ import { recordIterationPromptForTask } from "./iteration-log.js";
 import { resolveSystemAiContext } from "./session-ai-context.js";
 import { memberAgents } from "./ai-team-types.js";
 import { selectEmployeeCandidate } from "./silicon-employee-dispatch.js";
+import { defaultRoleForCli } from "./default-employee.js";
 import { DEFAULT_WAND_TASK_AGENT_KIND, DEFAULT_WAND_TASK_AGENT_MODE, DEFAULT_WAND_TASK_PRIORITY, isWandTaskAgentKind, isWandTaskAgentMode, normalizeWandTaskAgentMode, WAND_MILESTONE_NAME_MAX_LENGTH } from "./task-types.js";
 import { isAutoNameableBoardTask, taskAutoNameSignature, taskAutoNameSourceText } from "./wand-task-sync.js";
 import { isSessionProvider } from "./session-provider.js";
@@ -697,8 +698,12 @@ export function registerTaskRoutes(app, deps) {
             const cliDefault = subject?.type === "cli"
                 ? parseTaskAgent({ ...cliAgentForSubject(subject, task.agent), ...(body.kind === "pty" ? { kind: "pty" } : {}) })
                 : null;
+            const fallbackCandidate = !subject && body.agent === undefined && !task.agent
+                && !body.provider ? selectEmployeeCandidate(defaultRoleForCli(storage, config.defaultProvider)).agent : null;
+            const fallbackAgent = fallbackCandidate && body.kind === "pty"
+                ? { ...fallbackCandidate, kind: "pty" } : fallbackCandidate;
             const agent = selected?.agent ?? (body.agent === undefined
-                ? cliDefault ?? task.agent ?? parseWandTaskAgent(JSON.stringify(body))
+                ? cliDefault ?? task.agent ?? fallbackAgent ?? parseWandTaskAgent(JSON.stringify(body))
                 : parseTaskAgent(body.agent, task.agent?.mode, task.agent?.kind));
             if (!agent)
                 throw new Error("请先为该任务选择 CLI 工具。");

package/dist/server-user-memory.d.ts

@@ -0,0 +1,9 @@
+import type { Express, RequestHandler } from "express";
+import type { WandStorage } from "./storage.js";
+import { type UserMemoryService } from "./user-memory.js";
+export declare function userMemoryOperationLog(storage: WandStorage): RequestHandler;
+export declare function registerUserMemoryRoutes(app: Express, deps: {
+    storage: WandStorage;
+    service: UserMemoryService;
+    notifyChanged?: (id: string) => void;
+}): void;

package/dist/server-user-memory.js

@@ -0,0 +1,96 @@
+import { asyncRoute } from "./express-async.js";
+import { bodyObject, sendRouteError } from "./server-request.js";
+import { recordUserMemory } from "./user-memory.js";
+import { DEFAULT_EMPLOYEE_ID } from "./ai-team-types.js";
+import { isTaskExecutionSubject } from "./task-types.js";
+import { shouldGenerateSessionTopicFromInput } from "./session-topic.js";
+/** Explicit allowlist: never collect GET polling, auth, vault, config, files or tool bodies. */
+const OPERATIONS = [
+    { method: "POST", path: /^\/api\/(?:wand-tasks|tasks|workspaces\/[^/]+\/tasks)$/, feature: "task.create", fields: ["description", "title", "name"] },
+    { method: "PATCH", path: /^\/api\/(?:wand-tasks|workspace-tasks)\/[^/]+$/, feature: "task.edit", fields: ["description", "title", "name"] },
+    { method: "POST", path: /^\/api\/wand-tasks\/[^/]+\/dispatch$/, feature: "task.dispatch", fields: ["prompt"] },
+    { method: "POST", path: /^\/api\/(?:ai-teams\/[^/]+\/runs|wand-tasks\/[^/]+\/team-runs)$/, feature: "team.start", fields: ["note"] },
+    { method: "POST", path: /^\/api\/sessions\/[^/]+\/model$/, feature: "session.model" },
+    { method: "POST", path: /^\/api\/sessions\/[^/]+\/thinking-effort$/, feature: "session.thinking" },
+    { method: "POST", path: /^\/api\/sessions\/[^/]+\/mode$/, feature: "session.mode" },
+    { method: "POST", path: /^\/api\/sessions\/[^/]+\/quick-commit$/, feature: "git.quick-commit" },
+    { method: "POST", path: /^\/api\/sessions\/[^/]+\/upload$/, feature: "file.upload" },
+    { method: "POST", path: /^\/api\/sessions\/[^/]+\/worktree\/merge$/, feature: "worktree.merge" },
+    { method: "POST", path: /^\/api\/optimize-prompt$/, feature: "prompt.optimize", fields: ["text"] },
+    { method: "POST", path: /^\/api\/(?:sessions\/[^/]+\/input|structured-sessions\/[^/]+\/messages)$/, feature: "session.prompt", fields: ["input"] },
+];
+export function userMemoryOperationLog(storage) {
+    return (req, res, next) => {
+        const operation = OPERATIONS.find((entry) => entry.method === req.method && entry.path.test(req.path));
+        if (operation) {
+            const epoch = storage.userMemoryCaptureState();
+            const body = bodyObject(req.body);
+            const subject = body.executionSubject ?? body.subject;
+            const privateEmployee = isTaskExecutionSubject(subject) && subject.type === "employee"
+                && subject.id !== DEFAULT_EMPLOYEE_ID;
+            const observation = privateEmployee ? "" : (operation.fields ?? [])
+                .map((field) => typeof body[field] === "string" ? body[field] : "").filter(Boolean).join("\n");
+            // Only the successful user action is evidence. IDs/URLs and arbitrary request fields aren't logged.
+            res.once("finish", () => {
+                if (epoch.enabled && storage.userMemoryCaptureState().enabled
+                    && storage.userMemoryCaptureState().revision === epoch.revision
+                    && res.statusCode >= 200 && res.statusCode < 300) {
+                    if (operation.feature === "session.prompt") {
+                        // Team-generated instructions never pass through these authenticated input requests.
+                        // Only collect direct user replies here; interactive/wand-task runners already capture theirs.
+                        const sessionId = req.path.split("/")[3];
+                        const session = storage.getSessionSlim(sessionId);
+                        if (session?.sessionKind === "structured" && session.automationId?.startsWith("ai-team")
+                            && !/^[\/!]/.test(observation.trim()) && shouldGenerateSessionTopicFromInput(observation)) {
+                            recordUserMemory(storage, operation.feature, observation, sessionId);
+                        }
+                    }
+                    else {
+                        const taskId = operation.feature === "task.dispatch" || operation.feature === "task.edit"
+                            ? req.path.split("/")[3] : undefined;
+                        const taskSubject = taskId ? (req.path.split("/")[2] === "workspace-tasks"
+                            ? storage.getWandTaskByWorkspaceTaskId(taskId) : storage.getWandTask(taskId))?.executionSubject : null;
+                        const text = taskSubject?.type === "employee" && taskSubject.id !== DEFAULT_EMPLOYEE_ID
+                            ? "" : observation;
+                        recordUserMemory(storage, operation.feature, text, req.path);
+                    }
+                }
+            });
+        }
+        next();
+    };
+}
+export function registerUserMemoryRoutes(app, deps) {
+    const { storage, service, notifyChanged } = deps;
+    app.get("/api/user-memory", (_req, res) => {
+        res.setHeader("Cache-Control", "no-store");
+        res.json(service.view());
+    });
+    app.patch("/api/user-memory", (req, res) => {
+        try {
+            const body = bodyObject(req.body);
+            if (typeof body.enabled !== "boolean")
+                throw new Error("enabled 必须是布尔值。");
+            storage.setUserMemoryEnabled(body.enabled);
+            notifyChanged?.(DEFAULT_EMPLOYEE_ID);
+            res.json(service.view());
+        }
+        catch (error) {
+            sendRouteError(res, error, "无法调整短期记忆。");
+        }
+    });
+    app.delete("/api/user-memory", (_req, res) => {
+        storage.clearUserMemory();
+        notifyChanged?.(DEFAULT_EMPLOYEE_ID);
+        res.json(service.view());
+    });
+    app.post("/api/user-memory/refresh", asyncRoute(async (_req, res) => {
+        const updated = await service.refresh(true);
+        const view = service.view();
+        if (!updated && view.lastError) {
+            res.status(503).json({ error: view.lastError });
+            return;
+        }
+        res.json({ updated, ...view });
+    }));
+}

package/dist/server.js

@@ -33,6 +33,9 @@ import { Missions } from "./missions.js";
 import { createAiTeamRunner } from "./ai-team-runner.js";
 import { registerAiTeamRoutes } from "./server-ai-team-routes.js";
 import { registerSiliconEmployeeRoutes } from "./server-employee-routes.js";
+import { defaultRoleForCli } from "./default-employee.js";
+import { UserMemoryService } from "./user-memory.js";
+import { registerUserMemoryRoutes, userMemoryOperationLog } from "./server-user-memory.js";
 import { registerAttentionRoutes } from "./server-attention-routes.js";
 import { refreshProviderCliUpdateState, registerAdminUpdateRoutes, registerPublicUpdateRoutes, ServerUpdateState, } from "./server-update-routes.js";
 import { parseSessionCreationOrigin, registerClaudeHistoryRoutes, registerSessionRoutes } from "./server-session-routes.js";
@@ -288,6 +291,7 @@ export async function startServer(config, configPath, options = {}) {
     }
     const app = express();
     let shuttingDown = false;
+    const testMode = process.env.WAND_TEST_MODE === "1";
     app.set("trust proxy", "loopback, 172.16.0.0/12");
     const storage = new WandStorage(resolveDatabasePath(configPath));
     const runtimeConfig = new RuntimeConfigState(config);
@@ -310,6 +314,7 @@ export async function startServer(config, configPath, options = {}) {
             inheritEnv: config.inheritEnv !== false,
             apiKey: process.env.ANTHROPIC_API_KEY,
             ...injected,
+            piEndpointDiscovery: injected.piEndpointDiscovery ?? { enabled: !testMode },
             configuredClaudeModels: [
                 currentDefaults.claude,
                 config.commitCli === "claude" ? (storage.getPreference("pref:commitModel", config.commitModel) ?? "") : undefined,
@@ -599,6 +604,7 @@ export async function startServer(config, configPath, options = {}) {
         "/api/session-directories",
         "/api/structured-sessions",
         "/api/commands",
+        "/api/user-memory",
         "/api/claude-history",
         "/api/codex-history",
         "/api/opencode-history",
@@ -635,6 +641,16 @@ export async function startServer(config, configPath, options = {}) {
         "/api/local-file",
     ], requireFiles);
     app.use("/api/browser-extension", requirePasswordVault);
+    app.use("/api/silicon-employees/:employeeId/knowledge", requireSessions);
+    app.use(userMemoryOperationLog(storage));
+    const userMemory = new UserMemoryService({
+        storage, config,
+        notifyChanged: (employeeId) => notifyAiTeamRun({ kind: "silicon-employee-definition", employeeId }),
+    });
+    registerUserMemoryRoutes(app, {
+        storage, service: userMemory,
+        notifyChanged: (employeeId) => notifyAiTeamRun({ kind: "silicon-employee-definition", employeeId }),
+    });
     // ── Config & Session info ──
     app.get("/api/config", asyncRoute(async (req, res) => {
         const structuredChatPersona = await buildStructuredChatPersonaPayload(configPath, config);
@@ -833,7 +849,9 @@ export async function startServer(config, configPath, options = {}) {
                     cols: reqCols,
                     rows: reqRows,
                     thinkingEffort: body.thinkingEffort ?? config.defaultThinkingEffort,
-                    systemPrompt: body.systemPrompt,
+                    systemPrompt: body.systemPrompt?.trim() || (origin.sessionSource === "interactive"
+                        && (isSessionProvider(body.provider) || inferProviderFromCommand(command))
+                        ? defaultRoleForCli(storage, provider).prompt : undefined),
                     workspaceId,
                     workspaceTaskId: body.workspaceTaskId,
                     ...origin,
@@ -1049,8 +1067,9 @@ export async function startServer(config, configPath, options = {}) {
     if (!storage.hasCustomPassword() && config.password === "change-me") {
         wandWarn("正在使用默认密码（change-me），任何能访问本机的人都可以登录。", "修改方法：在界面右上角「设置」中修改密码，或运行：node dist/cli.js config:set password <你的新密码>");
     }
-    const testMode = process.env.WAND_TEST_MODE === "1";
     const updateChecksEnabled = !testMode && process.env.WAND_DISABLE_UPDATE_CHECK !== "1";
+    if (!testMode)
+        userMemory.start();
     // Start configured background sessions after the server is already reachable.
     if (!testMode) {
         void processes.runStartupCommands().catch((error) => {
@@ -1222,6 +1241,7 @@ export async function startServer(config, configPath, options = {}) {
             return closePromise;
         closePromise = (async () => {
             shuttingDown = true;
+            await userMemory.dispose();
             if (updateCheckTimer) {
                 clearInterval(updateCheckTimer);
                 updateCheckTimer = null;

package/dist/session-topic.js

@@ -257,11 +257,12 @@ export async function generateSessionTopic(userMessages, cwd, language, ai = {})
         ].join("\n"),
         prompt: `按发送顺序排列的用户消息：\n${input}`,
     };
-    const raw = await callConfiguredAiText(request, cwd ?? process.cwd(), language ?? "", ai);
-    const topic = parseTopic(raw);
-    if (!topic)
-        throw new Error("模型返回的会话主题格式无效。");
-    return topic;
+    return callConfiguredAiText(request, cwd ?? process.cwd(), language ?? "", ai, (raw) => {
+        const topic = parseTopic(raw);
+        if (!topic)
+            throw new Error("模型返回的会话主题格式无效。");
+        return topic;
+    });
 }
 /**
  * Coalesces title refreshes per session. A newer user message invalidates an

package/dist/silicon-employee-draft.js

@@ -132,9 +132,8 @@ export async function generateSiliconEmployeeDraft(expectation, ai = {}, options
     const available = availableEmployeeProviders(options.preferredProvider, options.isProviderAvailable);
     const providers = available.length ? available : [options.preferredProvider ?? "claude", ...SESSION_PROVIDERS];
     const request = buildEmployeeDraftPrompt(trimmed, providers, options.existingNames);
-    let raw;
     try {
-        raw = await callConfiguredAiText(request, options.cwd || process.cwd(), options.language ?? "", ai);
+        return await callConfiguredAiText(request, options.cwd || process.cwd(), options.language ?? "", ai, (raw) => parseSiliconEmployeeDraft(raw, { allowedProviders: providers, fallbackProvider: providers[0] }));
     }
     catch (error) {
         if (error instanceof SiliconEmployeeDraftError)
@@ -142,5 +141,4 @@ export async function generateSiliconEmployeeDraft(expectation, ai = {}, options
         const message = error instanceof Error ? error.message : String(error);
         throw new SiliconEmployeeDraftError(message || "AI 生成员工配置失败。", "DRAFT_AI_FAILED");
     }
-    return parseSiliconEmployeeDraft(raw, { allowedProviders: providers, fallbackProvider: providers[0] });
 }

package/dist/storage.d.ts

@@ -2,6 +2,8 @@ import { SessionSnapshot, ConversationTurn, SessionProvider, StructuredSessionSt
 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";
+import { type EmployeeKnowledgeEntry } from "./employee-knowledge-types.js";
+import { type UserMemoryEvent, type UserMemoryProfile, type UserMemoryState } from "./user-memory-types.js";
 import type { AgentActivityItem, Mission, MissionAttempt, MissionReviewComment, MissionReviewStatus, MissionStatus } from "./mission-types.js";
 import { type PasswordVault, type PasswordVaultItem, type PasswordVaultItemFilter, type PasswordVaultItemInput } from "./password-manager.js";
 /** `ai_team_runs.run_state_json`：本次运行的候选黑名单（§3.4 修正 B12 两层键值 + host-disabled）。 */
@@ -62,8 +64,10 @@ type WandTaskPatch = Partial<Pick<WandTask, "workspaceId" | "workspaceTaskId" |
 export declare class WandStorage {
     private readonly db;
     private readonly dbPath;
+    private memoryCapture;
     constructor(dbPath: string);
     directory(): string;
+    databasePath(): string;
     close(): void;
     /**
      * Run a synchronous group of storage operations atomically. Calls must not
@@ -315,7 +319,11 @@ export declare class WandStorage {
     listSiliconEmployees(options?: {
         includeArchived?: boolean;
     }): SiliconEmployee[];
+    private projectDefaultEmployee;
     getSiliconEmployee(id: string): SiliconEmployee | null;
+    getDefaultSiliconEmployee(): SiliconEmployee | null;
+    /** Seed once, preserve execution choices, and never reset learned preferences on restart. */
+    ensureDefaultSiliconEmployee(provider?: SessionProvider): SiliconEmployee;
     /** 内置「系统运维」员工；未创建（或被删除过）时返回 null。 */
     getSystemSiliconEmployee(key?: string): SiliconEmployee | null;
     /**
@@ -327,6 +335,36 @@ export declare class WandStorage {
     archiveSiliconEmployee(id: string, archivedAt?: string): void;
     unarchiveSiliconEmployee(id: string): void;
     deleteSiliconEmployee(id: string): void;
+    private requireKnowledgeEmployee;
+    listEmployeeKnowledge(employeeId: string, query?: string, limit?: number): EmployeeKnowledgeEntry[];
+    countEmployeeKnowledge(employeeId: string): number;
+    rememberEmployeeKnowledge(employeeId: string, value: string, accessToken?: string): EmployeeKnowledgeEntry;
+    forgetEmployeeKnowledge(employeeId: string, entryId: string, accessToken?: string): boolean;
+    clearEmployeeKnowledge(employeeId: string): void;
+    /** Opaque per-execution capability: no employee selector, app token or DB secret in model prompts. */
+    issueEmployeeKnowledgeAccess(sessionId: string, employeeId: string, now?: number): string;
+    resolveEmployeeKnowledgeAccess(token: string, now?: number): string | null;
+    revokeEmployeeKnowledgeAccess(token: string): void;
+    /** No IO on input hot paths; queued observations still CAS against the database before writing. */
+    userMemoryCaptureState(): Readonly<{
+        enabled: boolean;
+        revision: number;
+    }>;
+    stopUserMemoryCapture(): void;
+    getUserMemoryState(now?: number): UserMemoryState;
+    listUserMemoryEvents(now?: number, limit?: number): UserMemoryEvent[];
+    userMemoryFeatureCounts(now?: number): Array<{
+        feature: string;
+        count: number;
+    }>;
+    /** Only already-redacted, bounded observations reach this table. Queued writes use revision CAS. */
+    appendUserMemoryEvent(feature: string, text: string, dedupKey: string, revision: number, now?: number): void;
+    pruneUserMemory(now?: number): void;
+    setUserMemoryEnabled(enabled: boolean): void;
+    clearUserMemory(): void;
+    markUserMemoryAttempt(revision: number, now: number): boolean;
+    /** Read fresh candidates inside the transaction; a late model result cannot undo user edits/clear. */
+    applyUserMemoryProfile(profile: UserMemoryProfile, revision: number, sourceId: number, now?: number): boolean;
     listAiTeams(): AiTeam[];
     getAiTeam(id: string): AiTeam | null;
     saveAiTeam(team: AiTeam): void;