@co0ontty/wand 4.81.0 → 4.82.0

package/dist/storage.js

@@ -12,6 +12,11 @@ import { AI_TEAM_DEFAULT_MAX_STEPS, AI_TEAM_TERMINAL_RUN_STATUSES, aiTeamChatTit
 import { isTaskExecutionSubject } from "./task-types.js";
 import { SYSTEM_EMPLOYEE_KEY, systemEmployeeDefinition, systemEmployeeSeedAgents, } from "./system-employee.js";
 import { isThinkingEffort } from "./structured-provider-common.js";
+import { DEFAULT_EMPLOYEE_KEY } from "./ai-team-types.js";
+import { defaultEmployeeDefinition } from "./default-employee.js";
+import { normalizeEmployeeKnowledge } from "./employee-knowledge-content.js";
+import { EMPLOYEE_KNOWLEDGE_MAX_ENTRIES } from "./employee-knowledge-types.js";
+import { USER_MEMORY_MAX_EVENTS, USER_MEMORY_RETENTION_MS, } from "./user-memory-types.js";
 import { DEFAULT_PASSWORD_VAULT_ID, DEFAULT_PASSWORD_VAULT_NAME, decryptVaultSecret, encryptVaultSecret, itemMatchesFilter, normalizePasswordItemInput, normalizeVaultName, nowIso, } from "./password-manager.js";
 function safeJsonParse(raw) {
     if (!raw)
@@ -817,6 +822,41 @@ const INIT_SQL = `
   );
   CREATE INDEX IF NOT EXISTS idx_silicon_employees_archived ON silicon_employees(archived_at);
 
+  CREATE TABLE IF NOT EXISTS employee_knowledge (
+    id TEXT PRIMARY KEY,
+    employee_id TEXT NOT NULL REFERENCES silicon_employees(id) ON DELETE CASCADE,
+    content TEXT NOT NULL,
+    content_hash TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    UNIQUE (employee_id, content_hash)
+  );
+  CREATE INDEX IF NOT EXISTS idx_employee_knowledge_owner ON employee_knowledge(employee_id, created_at);
+  CREATE TABLE IF NOT EXISTS employee_knowledge_access (
+    token_hash TEXT PRIMARY KEY,
+    employee_id TEXT NOT NULL REFERENCES silicon_employees(id) ON DELETE CASCADE,
+    session_id TEXT NOT NULL REFERENCES command_sessions(id) ON DELETE CASCADE,
+    expires_at INTEGER NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS idx_employee_knowledge_access_expiry ON employee_knowledge_access(expires_at);
+
+  CREATE TABLE IF NOT EXISTS user_memory_events (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    feature TEXT NOT NULL,
+    text TEXT NOT NULL DEFAULT '',
+    dedup_key TEXT NOT NULL,
+    created_at INTEGER NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS idx_user_memory_events_created ON user_memory_events(created_at);
+  CREATE INDEX IF NOT EXISTS idx_user_memory_events_dedup ON user_memory_events(dedup_key, created_at);
+  CREATE TABLE IF NOT EXISTS user_memory_state (
+    id INTEGER PRIMARY KEY CHECK (id = 1),
+    enabled INTEGER NOT NULL DEFAULT 1,
+    revision INTEGER NOT NULL DEFAULT 0,
+    last_attempt_at INTEGER NOT NULL DEFAULT 0,
+    source_id INTEGER NOT NULL DEFAULT 0,
+    profile_json TEXT
+  );
+  INSERT OR IGNORE INTO user_memory_state (id) VALUES (1);
 
   CREATE TABLE IF NOT EXISTS ai_team_runs (
     id TEXT PRIMARY KEY,
@@ -1076,12 +1116,14 @@ function withoutSessionTab(node, sessionId) {
 export class WandStorage {
     db;
     dbPath;
+    memoryCapture = { enabled: true, revision: 0 };
     constructor(dbPath) {
         const dir = path.dirname(dbPath);
         mkdirSync(dir, { recursive: true, mode: 0o700 });
         chmodSync(dir, 0o700);
         this.dbPath = dbPath;
         this.db = new DatabaseSync(dbPath);
+        this.db.exec("PRAGMA busy_timeout = 5000");
         chmodSync(dbPath, 0o600);
         this.db.exec(INIT_SQL);
         ensureAuthSessionSchema(this.db);
@@ -1094,10 +1136,15 @@ export class WandStorage {
         ensureConnectorSchema(this.db);
         this.ensureDefaultPasswordVault();
         this.migrateTaskRecords();
+        const memory = this.getUserMemoryState();
+        this.memoryCapture = { enabled: memory.enabled, revision: memory.revision };
     }
     directory() {
         return path.dirname(this.dbPath);
     }
+    databasePath() {
+        return this.dbPath;
+    }
     close() {
         this.db.close();
     }
@@ -2311,11 +2358,34 @@ export class WandStorage {
             ? "SELECT * FROM silicon_employees ORDER BY (system_key IS NULL), created_at ASC"
             : "SELECT * FROM silicon_employees WHERE archived_at IS NULL ORDER BY (system_key IS NULL), created_at ASC";
         const rows = this.db.prepare(sql).all();
-        return rows.map(mapSiliconEmployeeRow);
+        return rows.map((row) => this.projectDefaultEmployee(mapSiliconEmployeeRow(row)));
+    }
+    projectDefaultEmployee(employee) {
+        if (employee.systemKey !== DEFAULT_EMPLOYEE_KEY)
+            return employee;
+        const state = this.getUserMemoryState();
+        return defaultEmployeeDefinition(employee.agents, employee.updatedAt, employee, state.enabled ? state.profile : null);
     }
     getSiliconEmployee(id) {
         const row = this.db.prepare("SELECT * FROM silicon_employees WHERE id = ?").get(id);
-        return row ? mapSiliconEmployeeRow(row) : null;
+        return row ? this.projectDefaultEmployee(mapSiliconEmployeeRow(row)) : null;
+    }
+    getDefaultSiliconEmployee() {
+        const employee = this.getSystemSiliconEmployee(DEFAULT_EMPLOYEE_KEY);
+        return employee ? this.projectDefaultEmployee(employee) : null;
+    }
+    /** Seed once, preserve execution choices, and never reset learned preferences on restart. */
+    ensureDefaultSiliconEmployee(provider) {
+        const existing = this.getSystemSiliconEmployee(DEFAULT_EMPLOYEE_KEY);
+        const state = this.getUserMemoryState();
+        const definition = defaultEmployeeDefinition(existing?.agents ?? systemEmployeeSeedAgents({ provider }), new Date().toISOString(), existing, state.enabled ? state.profile : null);
+        if (!existing || existing.name !== definition.name || existing.duty !== definition.duty
+            || existing.prompt !== definition.prompt || existing.avatar !== definition.avatar
+            || existing.archivedAt || !existing.agents.length) {
+            this.saveSiliconEmployee(definition);
+            return definition;
+        }
+        return existing;
     }
     /** 内置「系统运维」员工；未创建（或被删除过）时返回 null。 */
     getSystemSiliconEmployee(key = SYSTEM_EMPLOYEE_KEY) {
@@ -2368,6 +2438,209 @@ export class WandStorage {
     deleteSiliconEmployee(id) {
         this.db.prepare("DELETE FROM silicon_employees WHERE id = ?").run(id);
     }
+    // ============ Employee-owned explicit knowledge ============
+    requireKnowledgeEmployee(employeeId) {
+        if (!this.db.prepare("SELECT id FROM silicon_employees WHERE id = ?").get(employeeId)) {
+            throw new Error("员工已删除或不存在，不能改存到其他员工的知识库。");
+        }
+    }
+    listEmployeeKnowledge(employeeId, query = "", limit = 20) {
+        this.requireKnowledgeEmployee(employeeId);
+        const normalizedQuery = query.trim().slice(0, 200).toLowerCase();
+        const boundedLimit = Math.max(1, Math.min(Math.floor(limit), EMPLOYEE_KNOWLEDGE_MAX_ENTRIES));
+        // SQLite lower() is ASCII-only. Load at most this employee's fixed quota,
+        // perform Unicode case folding, and apply the result limit after filtering.
+        const rows = this.db.prepare(`SELECT id, employee_id, content, created_at FROM employee_knowledge
+      WHERE employee_id = ? ORDER BY created_at DESC, rowid DESC LIMIT ?`)
+            .all(employeeId, EMPLOYEE_KNOWLEDGE_MAX_ENTRIES);
+        return rows.filter((row) => row.content.toLowerCase().includes(normalizedQuery))
+            .slice(0, boundedLimit).map((row) => ({
+            id: row.id, employeeId: row.employee_id, content: row.content, createdAt: row.created_at,
+        }));
+    }
+    countEmployeeKnowledge(employeeId) {
+        this.requireKnowledgeEmployee(employeeId);
+        return Number(this.db.prepare("SELECT COUNT(*) AS count FROM employee_knowledge WHERE employee_id = ?")
+            .get(employeeId)?.count ?? 0);
+    }
+    rememberEmployeeKnowledge(employeeId, value, accessToken) {
+        const content = normalizeEmployeeKnowledge(value);
+        const hash = crypto.createHash("sha256").update(content).digest("hex");
+        return this.transaction(() => {
+            this.requireKnowledgeEmployee(employeeId);
+            if (accessToken && this.resolveEmployeeKnowledgeAccess(accessToken) !== employeeId) {
+                throw new Error("知识库访问已失效，请等待新的会话执行。");
+            }
+            const existing = this.db.prepare("SELECT id, content, created_at FROM employee_knowledge WHERE employee_id = ? AND content_hash = ?")
+                .get(employeeId, hash);
+            if (existing)
+                return { id: String(existing.id), employeeId,
+                    content: String(existing.content), createdAt: String(existing.created_at) };
+            if (this.countEmployeeKnowledge(employeeId) >= EMPLOYEE_KNOWLEDGE_MAX_ENTRIES) {
+                throw new Error("该员工知识库已满，请先删除不需要的内容，不会自动丢弃旧知识。");
+            }
+            const entry = { id: `k_${crypto.randomUUID().replace(/-/g, "")}`, employeeId,
+                content, createdAt: new Date().toISOString() };
+            this.db.prepare(`INSERT INTO employee_knowledge (id, employee_id, content, content_hash, created_at)
+        VALUES (?, ?, ?, ?, ?)`).run(entry.id, employeeId, content, hash, entry.createdAt);
+            return entry;
+        });
+    }
+    forgetEmployeeKnowledge(employeeId, entryId, accessToken) {
+        return this.transaction(() => {
+            this.requireKnowledgeEmployee(employeeId);
+            if (accessToken && this.resolveEmployeeKnowledgeAccess(accessToken) !== employeeId) {
+                throw new Error("知识库访问已失效，请等待新的会话执行。");
+            }
+            return this.db.prepare("DELETE FROM employee_knowledge WHERE employee_id = ? AND id = ?")
+                .run(employeeId, entryId).changes === 1;
+        });
+    }
+    clearEmployeeKnowledge(employeeId) {
+        this.transaction(() => {
+            this.requireKnowledgeEmployee(employeeId);
+            this.db.prepare("DELETE FROM employee_knowledge WHERE employee_id = ?").run(employeeId);
+            this.db.prepare("DELETE FROM employee_knowledge_access WHERE employee_id = ?").run(employeeId);
+        });
+    }
+    /** Opaque per-execution capability: no employee selector, app token or DB secret in model prompts. */
+    issueEmployeeKnowledgeAccess(sessionId, employeeId, now = Date.now()) {
+        this.requireKnowledgeEmployee(employeeId);
+        const row = this.getSessionSlim(sessionId);
+        if (!row || row.employeeId !== employeeId)
+            throw new Error("知识库归属与会话员工不一致。");
+        this.db.prepare("DELETE FROM employee_knowledge_access WHERE expires_at <= ?").run(now);
+        const token = crypto.randomBytes(32).toString("base64url");
+        const hash = crypto.createHash("sha256").update(token).digest("hex");
+        this.db.prepare(`INSERT INTO employee_knowledge_access (token_hash, employee_id, session_id, expires_at)
+      VALUES (?, ?, ?, ?)`).run(hash, employeeId, sessionId, now + 6 * 60 * 60 * 1000);
+        return token;
+    }
+    resolveEmployeeKnowledgeAccess(token, now = Date.now()) {
+        if (!/^[A-Za-z0-9_-]{43}$/.test(token))
+            return null;
+        const hash = crypto.createHash("sha256").update(token).digest("hex");
+        const row = this.db.prepare(`SELECT a.employee_id FROM employee_knowledge_access a
+      JOIN command_sessions s ON s.id = a.session_id JOIN silicon_employees e ON e.id = a.employee_id
+      WHERE a.token_hash = ? AND a.expires_at > ? AND json_extract(s.session_options, '$.employeeId') = a.employee_id`)
+            .get(hash, now);
+        return typeof row?.employee_id === "string" ? row.employee_id : null;
+    }
+    revokeEmployeeKnowledgeAccess(token) {
+        this.db.prepare("DELETE FROM employee_knowledge_access WHERE token_hash = ?")
+            .run(crypto.createHash("sha256").update(token).digest("hex"));
+    }
+    // ============ User short-term memory ============
+    /** No IO on input hot paths; queued observations still CAS against the database before writing. */
+    userMemoryCaptureState() {
+        return this.memoryCapture;
+    }
+    stopUserMemoryCapture() {
+        this.memoryCapture = { ...this.memoryCapture, enabled: false };
+    }
+    getUserMemoryState(now = Date.now()) {
+        const row = this.db.prepare("SELECT * FROM user_memory_state WHERE id = 1").get();
+        const candidate = safeJsonParse(row.profile_json);
+        let profile = candidate && candidate.expiresAt > now && Array.isArray(candidate.preferences)
+            && candidate.preferences.length <= 10 && candidate.preferences.every((entry) => entry && typeof entry.text === "string" && entry.text.length <= 160
+            && Array.isArray(entry.evidenceIds) && entry.evidenceIds.length <= 5
+            && entry.evidenceIds.every((id) => Number.isSafeInteger(id))) ? candidate : null;
+        const ids = profile ? [...new Set(profile.preferences.flatMap((entry) => entry.evidenceIds))] : [];
+        if (ids.length) {
+            const count = this.db.prepare(`SELECT COUNT(*) AS total FROM user_memory_events
+        WHERE id IN (${ids.map(() => "?").join(",")}) AND created_at > ? AND created_at <= ?`)
+                .get(...ids, now - USER_MEMORY_RETENTION_MS, now)?.total;
+            if (count !== ids.length)
+                profile = null;
+        }
+        return {
+            enabled: row.enabled === 1,
+            revision: Number(row.revision),
+            lastAttemptAt: Number(row.last_attempt_at),
+            sourceId: Number(row.source_id),
+            profile,
+        };
+    }
+    listUserMemoryEvents(now = Date.now(), limit = 80) {
+        const rows = this.db.prepare(`SELECT id, feature, text, created_at FROM user_memory_events
+      WHERE created_at > ? AND created_at <= ? ORDER BY id DESC LIMIT ?`)
+            .all(now - USER_MEMORY_RETENTION_MS, now, Math.max(1, Math.min(limit, USER_MEMORY_MAX_EVENTS)));
+        return rows.reverse().map((row) => ({
+            id: row.id, feature: row.feature, text: row.text, createdAt: row.created_at,
+        }));
+    }
+    userMemoryFeatureCounts(now = Date.now()) {
+        return this.db.prepare(`SELECT feature, COUNT(*) AS count FROM user_memory_events
+      WHERE created_at > ? AND created_at <= ? GROUP BY feature ORDER BY count DESC, feature`)
+            .all(now - USER_MEMORY_RETENTION_MS, now);
+    }
+    /** Only already-redacted, bounded observations reach this table. Queued writes use revision CAS. */
+    appendUserMemoryEvent(feature, text, dedupKey, revision, now = Date.now()) {
+        this.transaction(() => {
+            const state = this.getUserMemoryState(now);
+            if (!state.enabled || state.revision !== revision)
+                return;
+            this.pruneUserMemory(now);
+            const duplicate = this.db.prepare(`SELECT id FROM user_memory_events
+        WHERE dedup_key = ? AND created_at > ? LIMIT 1`).get(dedupKey, now - 120_000);
+            if (duplicate)
+                return;
+            this.db.prepare(`INSERT INTO user_memory_events (feature, text, dedup_key, created_at)
+        VALUES (?, ?, ?, ?)`).run(feature, text, dedupKey, now);
+            this.db.prepare(`DELETE FROM user_memory_events WHERE id NOT IN
+        (SELECT id FROM user_memory_events ORDER BY id DESC LIMIT ?)`)
+                .run(USER_MEMORY_MAX_EVENTS);
+            this.pruneUserMemory(now);
+        });
+    }
+    pruneUserMemory(now = Date.now()) {
+        this.db.prepare("DELETE FROM user_memory_events WHERE created_at <= ?")
+            .run(now - USER_MEMORY_RETENTION_MS);
+        const saved = this.db.prepare("SELECT profile_json FROM user_memory_state WHERE id = 1").get();
+        if (saved?.profile_json && !this.getUserMemoryState(now).profile) {
+            this.db.exec("UPDATE user_memory_state SET profile_json = NULL, source_id = 0 WHERE id = 1");
+            this.ensureDefaultSiliconEmployee();
+        }
+    }
+    setUserMemoryEnabled(enabled) {
+        this.transaction(() => {
+            this.db.prepare(`UPDATE user_memory_state SET enabled = ?, revision = revision + 1,
+        last_attempt_at = 0, source_id = 0, profile_json = NULL WHERE id = 1`).run(enabled ? 1 : 0);
+            this.ensureDefaultSiliconEmployee();
+        });
+        this.memoryCapture = { enabled, revision: this.memoryCapture.revision + 1 };
+    }
+    clearUserMemory() {
+        this.transaction(() => {
+            this.db.exec(`DELETE FROM user_memory_events;
+        UPDATE user_memory_state SET revision = revision + 1, last_attempt_at = 0,
+          source_id = 0, profile_json = NULL WHERE id = 1;`);
+            this.ensureDefaultSiliconEmployee();
+        });
+        this.memoryCapture = { ...this.memoryCapture, revision: this.memoryCapture.revision + 1 };
+    }
+    markUserMemoryAttempt(revision, now) {
+        return this.db.prepare(`UPDATE user_memory_state SET last_attempt_at = ?
+      WHERE id = 1 AND enabled = 1 AND revision = ?`).run(now, revision).changes === 1;
+    }
+    /** Read fresh candidates inside the transaction; a late model result cannot undo user edits/clear. */
+    applyUserMemoryProfile(profile, revision, sourceId, now = Date.now()) {
+        return this.transaction(() => {
+            const state = this.getUserMemoryState(now);
+            if (!state.enabled || state.revision !== revision || profile.expiresAt <= now)
+                return false;
+            const evidence = this.db.prepare("SELECT created_at FROM user_memory_events WHERE id = ?");
+            for (const id of new Set(profile.preferences.flatMap((entry) => entry.evidenceIds))) {
+                const row = evidence.get(id);
+                if (!row || Number(row.created_at) <= now - USER_MEMORY_RETENTION_MS)
+                    return false;
+            }
+            this.db.prepare(`UPDATE user_memory_state SET profile_json = ?, source_id = ? WHERE id = 1`)
+                .run(JSON.stringify(profile), sourceId);
+            this.ensureDefaultSiliconEmployee();
+            return true;
+        });
+    }
     // ============ AI Teams ============
     listAiTeams() {
         const rows = this.db.prepare("SELECT * FROM ai_teams ORDER BY created_at ASC").all();
@@ -2521,7 +2794,7 @@ export class WandStorage {
        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
        ON CONFLICT(id) DO UPDATE SET
          session_id = excluded.session_id, status = excluded.status, report = excluded.report,
-         instructions = excluded.instructions,
+         instructions = excluded.instructions, report_path = excluded.report_path,
          depends_on_json = excluded.depends_on_json,
          dispatch_info_json = excluded.dispatch_info_json,
          started_at = excluded.started_at, ended_at = excluded.ended_at`).run(step.id, step.runId, step.seq, step.kind, step.memberId, step.title, step.instructions, step.sessionId, step.status, step.report, step.reportPath, JSON.stringify(step.dependsOn), step.startedAt, step.endedAt, JSON.stringify(step.dispatchInfo ?? { usedCandidate: 0, skipped: [] }));

package/dist/structured-claude-adapter.d.ts

@@ -12,7 +12,7 @@ export declare function buildAppendSystemPromptParts(language: string | undefine
  * 完整 append 列表：模式 / 语言指令 + 会话级系统提示（团队、自动化会话的角色与规则）。
  * CLI 与 SDK 两条路径共用，避免只改一边。
  */
-export declare function buildSessionSystemPromptParts(session: Pick<SessionSnapshot, "mode" | "systemPrompt">, language: string | undefined): string[];
+export declare function buildSessionSystemPromptParts(session: Pick<SessionSnapshot, "mode" | "systemPrompt" | "runtimeSystemPrompt">, language: string | undefined): string[];
 export interface ClaudeCliArgsOptions {
     permissionPolicy: PermissionPolicy;
     systemPromptParts?: string[];

package/dist/structured-claude-adapter.js

@@ -101,6 +101,8 @@ export function buildSessionSystemPromptParts(session, language) {
     const sessionPrompt = session.systemPrompt?.trim();
     if (sessionPrompt)
         parts.push(sessionPrompt);
+    if (session.runtimeSystemPrompt?.trim())
+        parts.push(session.runtimeSystemPrompt.trim());
     return parts;
 }
 export function buildClaudeCliArgs(session, options) {

package/dist/structured-provider-common.d.ts

@@ -7,12 +7,12 @@ import type { SessionProvider, SessionRunner, SessionSnapshot, StructuredSession
  */
 export declare function systemPromptFlag(provider: SessionProvider | null | undefined): string | null;
 /** 结构化 runner 的 args：provider 支持时把系统提示当成独立参数传。 */
-export declare function systemPromptArgs(session: Pick<SessionSnapshot, "provider" | "systemPrompt">): string[];
+export declare function systemPromptArgs(session: Pick<SessionSnapshot, "provider" | "systemPrompt" | "runtimeSystemPrompt">): string[];
 /**
  * provider 没有系统提示通道时的兜底：把它放在本会话第一条消息最前面，并写明它不是用户输入。
  * 只在首轮拼一次：后续轮次的消息已经接在有它的对话历史后面。有通道的 provider 不会走这里。
  */
-export declare function promptWithSystemFallback(session: Pick<SessionSnapshot, "provider" | "systemPrompt" | "messages">, prompt: string): string;
+export declare function promptWithSystemFallback(session: Pick<SessionSnapshot, "provider" | "systemPrompt" | "runtimeSystemPrompt" | "messages">, prompt: string): string;
 /** provider 没有系统提示通道时的并接格式：明确标出这不是用户输入。 */
 export declare function composeSystemFallback(systemPrompt: string, prompt: string): string;
 /** 把系统提示接到 CLI 命令上（provider 支持时）；不支持时原样返回，由调用方并进首条输入。 */

package/dist/structured-provider-common.js

@@ -20,7 +20,7 @@ export function systemPromptFlag(provider) {
 }
 /** 结构化 runner 的 args：provider 支持时把系统提示当成独立参数传。 */
 export function systemPromptArgs(session) {
-    const text = session.systemPrompt?.trim();
+    const text = [session.systemPrompt?.trim(), session.runtimeSystemPrompt?.trim()].filter(Boolean).join("\n\n");
     if (!text)
         return [];
     const flag = systemPromptFlag(session.provider);
@@ -31,12 +31,12 @@ export function systemPromptArgs(session) {
  * 只在首轮拼一次：后续轮次的消息已经接在有它的对话历史后面。有通道的 provider 不会走这里。
  */
 export function promptWithSystemFallback(session, prompt) {
-    const text = session.systemPrompt?.trim();
-    if (!text || systemPromptFlag(session.provider))
+    if (systemPromptFlag(session.provider))
         return prompt;
-    if ((session.messages?.length ?? 0) > 1)
-        return prompt;
-    return composeSystemFallback(text, prompt);
+    const base = (session.messages?.length ?? 0) <= 1 ? session.systemPrompt?.trim() : "";
+    // Knowledge is live per turn, including resumed Codex/OpenCode/Gemini conversations.
+    const text = [base, session.runtimeSystemPrompt?.trim()].filter(Boolean).join("\n\n");
+    return text ? composeSystemFallback(text, prompt) : prompt;
 }
 /** provider 没有系统提示通道时的并接格式：明确标出这不是用户输入。 */
 export function composeSystemFallback(systemPrompt, prompt) {

package/dist/structured-session-manager.js

@@ -6,6 +6,7 @@ import { buildChildEnv } from "./env-utils.js";
 import { getErrorMessage } from "./error-utils.js";
 import { getDefaultModelForProvider } from "./config.js";
 import { recordIterationPrompt } from "./iteration-log.js";
+import { startEmployeeKnowledgeRunner } from "./employee-knowledge.js";
 import { signalNameFromNumber } from "./signal-utils.js";
 import { provisionalSessionTopic, SessionNativeTitleTracker, SessionTopicCoordinator, sessionTopicBlocklistForSnapshot, shouldAcceptGeneratedSessionTitle, shouldGenerateSessionTopicFromInput, } from "./session-topic.js";
 import { resolveSessionCwd } from "./session-cwd.js";
@@ -2037,7 +2038,7 @@ export class StructuredSessionManager {
                 emitTimer = this.trackStreamEmitTimer(setTimeout(flushEmit, STREAM_EMIT_DEBOUNCE_MS));
             }
         };
-        const execution = this.codexRunner.start({
+        const execution = startEmployeeKnowledgeRunner(this.storage, this.codexRunner, {
             session,
             prompt,
             env: buildChildEnv(this.config.inheritEnv !== false),
@@ -2183,7 +2184,7 @@ export class StructuredSessionManager {
             if (!emitTimer)
                 emitTimer = this.trackStreamEmitTimer(setTimeout(flushEmit, STREAM_EMIT_DEBOUNCE_MS));
         };
-        const execution = this.grokRunner.start({
+        const execution = startEmployeeKnowledgeRunner(this.storage, this.grokRunner, {
             session,
             prompt,
             env: buildChildEnv(this.config.inheritEnv !== false),
@@ -2325,7 +2326,7 @@ export class StructuredSessionManager {
                 emitTimer = this.trackStreamEmitTimer(setTimeout(flushEmit, STREAM_EMIT_DEBOUNCE_MS));
             }
         };
-        const execution = this.openCodeRunner.start({
+        const execution = startEmployeeKnowledgeRunner(this.storage, this.openCodeRunner, {
             session,
             prompt,
             env: buildChildEnv(this.config.inheritEnv !== false),
@@ -2501,7 +2502,7 @@ export class StructuredSessionManager {
         const provider = options.provider ?? "claude";
         const commandLabel = options.commandLabel ?? "claude -p";
         const logKind = options.logKind ?? "claude-print";
-        const execution = runner.start({
+        const execution = startEmployeeKnowledgeRunner(this.storage, runner, {
             session,
             prompt,
             env: buildChildEnv(this.config.inheritEnv !== false),

package/dist/task-title.js

@@ -78,11 +78,12 @@ export async function generateWandTaskTitle(description, cwd, language = "", ai
         ].join("\n"),
         prompt: `任务描述：\n${input}`,
     };
-    const raw = await callConfiguredAiText(request, cwd || process.cwd(), language, ai);
-    const stripped = stripGeneratedTitle(raw);
-    // 拿到报错文案 / 整段解释时宁可保留占位标题，也不能把垃圾写进看板。
-    // 先判可信度再裁剪：截断过的长句看起来就像标题，会绕过长度检查。
-    if (!isPlausibleTaskTitle(stripped))
-        throw new Error("模型返回的任务标题不可用。");
-    return clipAtWordBoundary(stripped, TASK_TITLE_MAX_LENGTH);
+    return callConfiguredAiText(request, cwd || process.cwd(), language, ai, (raw) => {
+        const stripped = stripGeneratedTitle(raw);
+        // 校验在候选链内：格式不可用也要继续备用候选，不能先把非空文本当成功。
+        // 先判可信度再裁剪：截断过的长句看起来就像标题，会绕过长度检查。
+        if (!isPlausibleTaskTitle(stripped))
+            throw new Error("模型返回的任务标题不可用。");
+        return clipAtWordBoundary(stripped, TASK_TITLE_MAX_LENGTH);
+    });
 }

package/dist/team-report-file-link.d.ts

@@ -0,0 +1,6 @@
+/** 只识别明确交付的报告链接，不能把普通代码/历史文档或外部 URL 当成新报告。 */
+export declare function linkedTeamReportFile(cwd: string, reply: string, startedAt: string | null): {
+    path: string;
+    relativePath: string;
+    mtimeMs: number;
+} | null;

package/dist/team-report-file-link.js

@@ -0,0 +1,54 @@
+import { realpathSync, statSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+/** 只识别明确交付的报告链接，不能把普通代码/历史文档或外部 URL 当成新报告。 */
+export function linkedTeamReportFile(cwd, reply, startedAt) {
+    const started = Date.parse(startedAt ?? "");
+    if (!Number.isFinite(started))
+        return null;
+    const candidates = new Map();
+    try {
+        const root = realpathSync(cwd);
+        const links = /\[([^\]\r\n]+)\]\(\s*(?:<([^>\r\n]+)>|([^\s)]+))\s*\)/g;
+        const references = [
+            ...[...reply.matchAll(links)].map((m) => ({ raw: m[2] ?? m[3], label: m[1], index: m.index, text: m[0] })),
+            ...[...reply.matchAll(/`([^`\r\n]+\.(?:md|markdown))`/gi)]
+                .map((m) => ({ raw: m[1], label: "", index: m.index, text: m[0] })),
+        ];
+        for (const reference of references) {
+            const { raw } = reference;
+            const before = reply.slice(reply.lastIndexOf("\n", reference.index) + 1, reference.index);
+            const delivered = /(?:已(?:写入|保存|生成|完成)|交付|报告(?:文件)?[：:]|report\s*[:：]|\b(?:written|saved|created|delivered)\b)/i.test(before)
+                || reply.trim() === reference.text;
+            if (!delivered || !/(?:报告|report)/i.test(`${reference.label} ${before} ${path.basename(raw)}`))
+                continue;
+            if (!/\.(?:md|markdown)$/i.test(raw))
+                continue;
+            try {
+                const local = /^file:/i.test(raw) ? fileURLToPath(raw)
+                    : /^[a-z][a-z\d+.-]*:/i.test(raw) && !path.isAbsolute(raw) ? null
+                        : decodeURIComponent(raw);
+                if (!local)
+                    continue;
+                const file = realpathSync(path.resolve(root, local));
+                const relativePath = path.relative(root, file);
+                if (!/\.(?:md|markdown)$/i.test(file))
+                    continue;
+                if (!relativePath || relativePath === ".." || relativePath.startsWith(`..${path.sep}`) || path.isAbsolute(relativePath))
+                    continue;
+                const stat = statSync(file);
+                // 文件系统有亚毫秒精度，startedAt 只有整数毫秒；同一毫秒不能误判为旧文件。
+                if (!stat.isFile() || Math.ceil(stat.mtimeMs) < started)
+                    continue;
+                candidates.set(file, { path: file, relativePath, mtimeMs: stat.mtimeMs });
+            }
+            catch {
+                // 无法读取/无效路径不构成文件交付，保留原有回复兜底。
+            }
+        }
+    }
+    catch {
+        return null;
+    }
+    return candidates.size === 1 ? [...candidates.values()][0] : null;
+}

package/dist/team-report-preview.d.ts

@@ -0,0 +1,3 @@
+import type { TeamReportFile } from "./types.js";
+/** 完成时冻结有界预览；后续群聊列表不为预览再次读取整份文件。 */
+export declare function teamReportPreview(text: string, fallbackTitle: string): NonNullable<TeamReportFile["preview"]>;

package/dist/team-report-preview.js

@@ -0,0 +1,70 @@
+const TITLE_LIMIT = 100;
+const EXCERPT_LIMIT = 240;
+const EXCERPT_LINES = 3;
+function bounded(text, limit) {
+    const chars = Array.from(text);
+    return chars.length > limit ? `${chars.slice(0, limit - 1).join("").trimEnd()}…` : text;
+}
+/** 只取真实文本，不渲染 Markdown/HTML、不读链接、不调用模型。 */
+function plainText(line) {
+    return line
+        .replace(/!\[([^\]]*)\]\([^)]*\)/g, "$1")
+        .replace(/\[([^\]]+)\]\([^)]*\)/g, "$1")
+        .replace(/<[^>]*>/g, "")
+        .replace(/(`+)(.*?)\1/g, "$2")
+        .replace(/(\*\*|__|~~)(.*?)\1/g, "$2")
+        .replace(/^\s*(?:>\s*)+/, "")
+        .replace(/^\s*(?:[-+*]|\d+[.)])\s+(?:\[[ xX]\]\s*)?/, "")
+        .replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, "")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+const SUMMARY_HEADING = /^(?:\d+[.、\s]*)?(?:结论|摘要|总结|概述|验证结果|summary|conclusions?)(?:[：:].*)?$/i;
+/** 完成时冻结有界预览；后续群聊列表不为预览再次读取整份文件。 */
+export function teamReportPreview(text, fallbackTitle) {
+    const source = text.slice(0, 64 * 1024)
+        .replace(/^\uFEFF/, "")
+        .replace(/^---\r?\n[\s\S]*?\r?\n---\s*(?:\r?\n|$)/, "")
+        .replace(/<!--[\s\S]*?-->/g, "")
+        .replace(/<(script|style)\b[^>]*>[\s\S]*?<\/\1>/gi, "");
+    const lines = source.split(/\r?\n/);
+    const entries = [];
+    let fence = null;
+    for (let i = 0; i < lines.length; i++) {
+        const raw = lines[i].trim();
+        const marker = /^(?:`{3,}|~{3,})/.exec(raw)?.[0];
+        if (marker) {
+            if (!fence)
+                fence = marker;
+            else if (marker[0] === fence[0] && marker.length >= fence.length && raw === marker)
+                fence = null;
+            continue;
+        }
+        if (fence || !raw || /^(?:[-*_]\s*){3,}$/.test(raw))
+            continue;
+        const heading = /^(#{1,6})\s+(.+?)(?:\s+#+)?$/.exec(raw);
+        const setext = /^(=+|-+)\s*$/.exec(lines[i + 1]?.trim() ?? "");
+        const value = plainText(heading ? heading[2] : raw);
+        if (!value)
+            continue;
+        entries.push({ text: value, heading: heading ? heading[1].length : setext ? (setext[1][0] === "=" ? 1 : 2) : 0 });
+        if (setext)
+            i++;
+    }
+    const titleEntry = entries.find((entry) => entry.heading === 1)
+        ?? entries.find((entry) => entry.heading > 0 && !SUMMARY_HEADING.test(entry.text));
+    const title = bounded(titleEntry?.text || plainText(fallbackTitle) || "成员报告", TITLE_LIMIT);
+    const summaryAt = entries.findIndex((entry) => entry.heading > 0 && SUMMARY_HEADING.test(entry.text));
+    let candidates = entries.filter((entry) => entry.heading === 0);
+    if (summaryAt >= 0) {
+        const section = entries.slice(summaryAt + 1);
+        const nextHeading = section.findIndex((entry) => entry.heading > 0);
+        const summary = section.slice(0, nextHeading < 0 ? section.length : nextHeading);
+        if (summary.length)
+            candidates = summary;
+    }
+    let excerpt = candidates.slice(0, EXCERPT_LINES).map((entry) => entry.text).join("\n");
+    if (candidates.length > EXCERPT_LINES)
+        excerpt += "…";
+    return { title, excerpt: bounded(excerpt, EXCERPT_LIMIT) };
+}

package/dist/types.d.ts

@@ -547,10 +547,23 @@ export interface ConversationAuthor {
     /** 这条发言对应的成员会话，可点开看完整过程。 */
     sessionId?: string;
 }
+/** 团队成员完成报告后投递的文件元数据；正文按需预览，不嵌进群聊。 */
+export interface TeamReportFile {
+    stepId: string;
+    path: string;
+    name: string;
+    size: number;
+    /** 完成时从原文件提取的标题与有限摘录；旧消息可缺省。 */
+    preview?: {
+        title: string;
+        excerpt: string;
+    };
+}
 export interface ConversationTurn {
     role: "user" | "assistant";
     content: ContentBlock[];
     author?: ConversationAuthor;
+    reportFile?: TeamReportFile;
     /** 群聊里的进度提示（派工、开始、出错）：渲染成居中的一行，不是气泡。 */
     notice?: boolean;
     /** ISO time when this turn was first recorded (user send / assistant start). */
@@ -598,6 +611,8 @@ export interface SessionSnapshot {
      * 不要拼进首条用户消息。provider 没有该通道时（codex / opencode）由调用方退回并入消息。
      */
     systemPrompt?: string | null;
+    /** Runner-only live employee knowledge. Never persisted in session_options or sent in DTOs. */
+    runtimeSystemPrompt?: string;
     /** 所属工作空间 ID（多标签 / 分屏项目）。会话在该工作空间窗口内作为一个标签。 */
     workspaceId?: string;
     /** 所属工作空间任务 ID；任务独占一个 worktree，其下所有会话共享该 worktree 目录。 */