@co0ontty/wand 4.94.0 → 4.95.0

package/dist/system-ai-session-recorder.js

@@ -0,0 +1,239 @@
+import { createHash, randomUUID } from "node:crypto";
+import { CONVERSATION_OWNER, employeeConversationId } from "./conversation-types.js";
+import { conversationSessionPreview } from "./conversation-session-preview.js";
+import { defaultStructuredRunner } from "./structured-provider-common.js";
+import { providerCliCommand } from "./provider-catalog.js";
+import { buildStructuredOutputPayload } from "./structured-session-manager-replay.js";
+import { AiCallTraceError, SYSTEM_AI_CALL_PREFIX, SYSTEM_AI_PURPOSES, SYSTEM_AI_READ_ONLY, isSystemAiCall } from "./system-ai-call.js";
+const INPUT_LIMIT = 24_000;
+const OUTPUT_LIMIT = 32_000;
+const MESSAGE_LIMIT = 256;
+const recorders = new WeakMap();
+/** Only copies business text. Never logs credential commands, runtime config, or provider error bodies. */
+export function redactSystemAiText(value) {
+    let text = value;
+    for (const [key, secret] of Object.entries(process.env)) {
+        if (/(?:KEY|TOKEN|PASSWORD|SECRET|CONNECTION_CODE)/i.test(key) && secret && secret.length >= 6)
+            text = text.split(secret).join("[已脱敏]");
+    }
+    text = text.replace(/-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g, "[私钥已脱敏]")
+        .replace(/\bBearer\s+[A-Za-z0-9._~+\/-]+=*/gi, "Bearer [已脱敏]")
+        .replace(/\b(?:sk-|ghp_|github_pat_|xox[baprs]-)[A-Za-z0-9_-]{10,}/g, "[已脱敏]")
+        .replace(/((?:["']?(?:api[_ -]?key|access[_ -]?token|connection[_ -]?code|password|secret|密钥|密码|口令|连接码)["']?)\s*[:=：]\s*)("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|[^\s"'，;\n}]+)/gi, (_all, key, value) => key + (value.startsWith('"') ? '"[已脱敏]"' : value.startsWith("'") ? "'[已脱敏]'" : "[已脱敏]"));
+    return text;
+}
+function logText(value, limit) {
+    const text = redactSystemAiText(value);
+    return text.length > limit ? text.slice(0, limit) + `\n（日志已限长，原始 ${text.length} 字符）` : text;
+}
+function resultText(value) {
+    if (typeof value === "string")
+        return value;
+    try {
+        return JSON.stringify(value, null, 2) ?? "（无返回值）";
+    }
+    catch {
+        return "（结果不可序列化）";
+    }
+}
+function failureCode(error) {
+    const value = error && typeof error === "object" && "code" in error ? String(error.code) : error instanceof Error ? error.name : "UNKNOWN";
+    return /^[A-Za-z0-9_-]{1,64}$/.test(value) ? value : "AI_CALL_FAILED";
+}
+function turn(text, notice = false) {
+    const now = new Date().toISOString();
+    return { role: "assistant", content: [{ type: "text", text }], notice, createdAt: now, completedAt: now };
+}
+export class SystemAiSessionRecorder {
+    storage;
+    closed = false;
+    active = new Set();
+    logger;
+    emit;
+    notifyConversation;
+    constructor(storage) {
+        this.storage = storage;
+        storage.onClose(() => { this.closed = true; });
+    }
+    attach(options) {
+        this.logger = options.logger ?? this.logger;
+        this.emit = options.emit ?? this.emit;
+        this.notifyConversation = options.notifyConversation ?? this.notifyConversation;
+    }
+    /** A server-owned one-shot has no detached runner to adopt after a restart. Never replay it. */
+    recoverInterrupted() {
+        for (const slim of this.storage.loadSessionsSlim()) {
+            if (!isSystemAiCall(slim) || slim.status !== "running" || this.active.has(slim.id))
+                continue;
+            const session = this.storage.getSession(slim.id);
+            if (!session)
+                continue;
+            const now = new Date().toISOString();
+            this.persist({ ...session, status: "failed", exitCode: 1, endedAt: now,
+                messages: [...(session.messages ?? []), turn("服务重启，本次系统调用结果未知；未自动重试。")],
+                ...(session.structuredState ? { structuredState: { ...session.structuredState, inFlight: false,
+                        activeRequestId: null, turnStartedAt: null, lastActivityAt: null, lastError: "服务重启，系统调用结果未知。" } } : {}),
+            }, false);
+        }
+    }
+    forEmployee(employee, sourceSessionId) {
+        const stored = this.storage.getSiliconEmployee(employee.id);
+        if (!stored || stored.systemKey !== employee.systemKey)
+            throw new AiCallTraceError();
+        // Freeze attribution, not the employee's private knowledge or current UI display name.
+        const actor = { id: employee.id, name: employee.name, avatar: employee.avatar, prompt: employee.prompt };
+        return { start: (purpose, request, cwd) => this.start(actor, purpose, request, cwd, sourceSessionId) };
+    }
+    remove(sessionId) {
+        const current = this.storage.getSessionSlim(sessionId);
+        if (!current || !isSystemAiCall(current))
+            return;
+        if (current.status === "running")
+            throw Object.assign(new Error("系统调用仍在执行，完成后才能删除日志。"), { statusCode: 409 });
+        this.storage.deleteSession(sessionId);
+        this.logger?.deleteSession(sessionId);
+    }
+    appendOutcome(sessionId, label, value) {
+        if (this.closed)
+            return;
+        const current = this.storage.getSession(sessionId);
+        if (!current || !isSystemAiCall(current))
+            return;
+        this.persist({ ...current, messages: [...(current.messages ?? []), turn(`## ${label}\n\n${logText(resultText(value), OUTPUT_LIMIT)}`)] }, false);
+    }
+    persist(snapshot, create) {
+        if (this.closed)
+            return;
+        try {
+            // Deletion is authoritative: late completion must never recreate a removed record or DM.
+            if (!create && !this.storage.getSessionSlim(snapshot.id))
+                return;
+            const conversationId = employeeConversationId(snapshot.employeeId);
+            if (create && this.storage.conversationListState(conversationId).deleting)
+                throw new AiCallTraceError();
+            this.storage.saveSession(snapshot);
+            if (!this.storage.conversationListState(conversationId).deleting) {
+                const instance = this.storage.getConversation(conversationId) ?? {
+                    id: conversationId, owner: CONVERSATION_OWNER, kind: "dm", peerEmployeeId: snapshot.employeeId,
+                    name: snapshot.employeeName, nameSource: "auto", sourceTemplateId: null, team: null,
+                    memberVersion: 1, joinedVersions: {}, sessionId: null, communicationSessionId: null,
+                    createdAt: snapshot.startedAt, updatedAt: snapshot.endedAt ?? snapshot.startedAt,
+                };
+                // Canonical link stores no second transcript and never pretends the system sent a user DM.
+                this.storage.linkEmployeeSession(instance, snapshot);
+                this.notifyConversation?.({ conversationId, sessionId: snapshot.id, preview: conversationSessionPreview(snapshot) });
+            }
+            this.logger?.saveMessages(snapshot.id, snapshot.messages ?? []);
+            this.logger?.saveMetadata(snapshot.id, { kind: "system-ai-call", employeeId: snapshot.employeeId,
+                operation: snapshot.title, provider: snapshot.provider, model: snapshot.selectedModel,
+                status: snapshot.status, startedAt: snapshot.startedAt, endedAt: snapshot.endedAt });
+            this.emit?.({ type: create ? "started" : "output",
+                sessionId: snapshot.id, data: { ...buildStructuredOutputPayload(snapshot),
+                    automationId: snapshot.automationId, sessionSource: snapshot.sessionSource,
+                    status: snapshot.status, exitCode: snapshot.exitCode, endedAt: snapshot.endedAt, } });
+        }
+        catch (error) {
+            if (error instanceof AiCallTraceError)
+                throw error;
+            throw new AiCallTraceError();
+        }
+    }
+    start(actor, purpose, request, cwd, sourceSessionId) {
+        const id = randomUUID(), now = new Date().toISOString();
+        const label = SYSTEM_AI_PURPOSES[purpose];
+        const system = actor.prompt && request.system.startsWith(actor.prompt) ? request.system.slice(actor.prompt.length).trim() : request.system;
+        const sensitiveInput = purpose.startsWith("git-") || purpose === "user-memory";
+        const input = sensitiveInput
+            ? `该输入可能包含源码差异或私人习惯语料，仅保存范围校验信息。\n字符数：${request.prompt.length}\nSHA256：${createHash("sha256").update(request.prompt).digest("hex")}`
+            : logText(request.prompt, INPUT_LIMIT);
+        let snapshot = {
+            id, sessionKind: "structured", sessionSource: "automation", automationId: `${SYSTEM_AI_CALL_PREFIX}${purpose}:${id}`,
+            employeeId: actor.id, employeeName: actor.name, employeeAvatar: actor.avatar,
+            command: "system-ai", cwd, mode: "default", status: "running", exitCode: null,
+            startedAt: now, endedAt: null, output: "", archived: false, archivedAt: null, claudeSessionId: null, worktreeEnabled: false,
+            title: `系统调用 · ${label}`, description: `${actor.name} · ${label} · 只读调用记录`,
+            completionRevision: 0, viewedCompletionRevision: 0,
+            messages: [{ role: "user", author: { id: "system", name: "系统" }, createdAt: now,
+                    content: [{ type: "text", text: `# ${label}\n\n${SYSTEM_AI_READ_ONLY}\n\n${sourceSessionId ? `关联会话：${sourceSessionId}\n\n` : ""}## 调用规则\n\n${logText(system, INPUT_LIMIT)}\n\n## 输入\n\n${input}` }] }],
+        };
+        this.active.add(id);
+        try {
+            this.persist(snapshot, true);
+        }
+        catch (error) {
+            this.active.delete(id);
+            throw error;
+        }
+        let finished = false, omitted = 0, attempts = 0, usageAvailable = false;
+        const append = (text, force = false) => {
+            if (finished)
+                return;
+            const messages = snapshot.messages ?? [];
+            if (messages.length >= MESSAGE_LIMIT && !force) {
+                omitted++;
+                const last = messages.at(-1);
+                const notice = turn(`候选明细达到日志上限，另外 ${omitted} 条已折叠；最终结果仍保留。`, true);
+                snapshot = { ...snapshot, messages: last?.notice ? [...messages.slice(0, -1), notice] : [...messages, notice] };
+            }
+            else
+                snapshot = { ...snapshot, messages: [...messages, turn(logText(text, OUTPUT_LIMIT))] };
+            this.persist(snapshot, false);
+        };
+        const finish = (status, message) => {
+            if (finished)
+                return;
+            if (message)
+                append(message, true);
+            finished = true;
+            this.active.delete(id);
+            snapshot = { ...snapshot, status, endedAt: new Date().toISOString(), exitCode: status === "exited" ? 0 : 1,
+                ...(snapshot.structuredState ? { structuredState: { ...snapshot.structuredState, inFlight: false,
+                        activeRequestId: null, turnStartedAt: null, lastActivityAt: null, lastError: status === "exited" ? null : message ?? "系统调用失败。" } } : {}),
+            };
+            this.persist(snapshot, false);
+        };
+        const candidateName = (candidate) => `${candidate.provider} / ${candidate.engine === "sdk" ? "Wand Agent SDK" : "CLI"} / ${candidate.model ?? "默认模型"}`;
+        return {
+            sessionId: id,
+            candidateStarted: candidate => {
+                attempts++;
+                const runner = defaultStructuredRunner(candidate.provider);
+                snapshot = { ...snapshot, provider: candidate.provider, runner, selectedModel: candidate.model ? logText(candidate.model, 256) : null,
+                    thinkingEffort: candidate.thinkingEffort ?? "off", command: providerCliCommand(candidate.provider),
+                    structuredState: { provider: candidate.provider, runner, model: candidate.model ? logText(candidate.model, 256) : undefined,
+                        engine: candidate.engine === "sdk" ? "core" : "cli", inFlight: true, activeRequestId: id,
+                        turnStartedAt: now, lastActivityAt: new Date().toISOString(), lastError: null } };
+                append(`候选 ${attempts}：开始尝试 ${candidateName(candidate)}。`);
+            },
+            localStarted: model => {
+                attempts++;
+                snapshot = { ...snapshot, provider: undefined, runner: undefined, structuredState: undefined,
+                    selectedModel: logText(model, 256), command: "local-decision" };
+                append(`候选 ${attempts}：开始本地决策 worker（${model}），不是 CLI 或 Wand Agent SDK。`);
+            },
+            candidateSkipped: (candidate, reason) => append(`未执行候选 ${candidateName(candidate)}：${reason}`),
+            candidateFailed: (candidate, error, phase) => append(`候选 ${candidateName(candidate)} ${phase === "availability" ? "准备" : phase === "result" ? "结果校验" : "调用"}失败（${failureCode(error)}）。未保存提供商错误正文。`),
+            candidateSucceeded: (raw, parsed) => {
+                append(`## 模型输出（已通过调用方校验）\n\n${raw}`, true);
+                if (typeof parsed !== "string" || parsed !== raw)
+                    append(`## 解析后的业务结果\n\n${resultText(parsed)}`, true);
+            },
+            usageReported: usage => {
+                usageAvailable = true;
+                snapshot = { ...snapshot, selectedModel: logText(usage.model, 256) };
+                append(`SDK 实际模型：${usage.model}；适配器统计输入 ${usage.inputTokens} / 输出 ${usage.outputTokens} tokens（不是账单审计）。`);
+            },
+            applicationResult: value => append(`## 实际业务执行结果\n\n${resultText(value)}`, true),
+            complete: () => finish("exited", `${attempts ? `调用完成；尝试了 ${attempts} 个候选。` : "系统操作已结束；本记录未直接请求模型。"}具体业务是否应用以单独记录的实际业务结果为准。${attempts && !usageAvailable ? "未采集到实际叶子/上游用量，不估算费用。" : ""}`),
+            fail: (error, cancelled = false) => finish(cancelled ? "stopped" : "failed", `${cancelled ? "调用已取消，结果不再应用" : "调用失败"}（${failureCode(error)}）；未自动扩大模型/费用范围。`),
+        };
+    }
+}
+export function systemAiSessions(storage) {
+    let recorder = recorders.get(storage);
+    if (!recorder) {
+        recorder = new SystemAiSessionRecorder(storage);
+        recorders.set(storage, recorder);
+    }
+    return recorder;
+}

package/dist/system-cli.d.ts

@@ -0,0 +1,6 @@
+import type { WandCliApi } from "./cli-api.js";
+type Api = Pick<WandCliApi, "get" | "post" | "patch">;
+type Operation = (api: Api) => Promise<unknown>;
+/** Parse before opening config/authentication; never retries mutations or accepts arbitrary API paths. */
+export declare function parseSystemCliCommand(command: string, args: string[], input?: AsyncIterable<string | Buffer>): Promise<Operation>;
+export {};

package/dist/system-cli.js

@@ -0,0 +1,93 @@
+const MAX_INPUT_BYTES = 1024 * 1024;
+async function jsonInput(input) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of input) {
+        const bytes = Buffer.from(chunk);
+        size += bytes.length;
+        if (size > MAX_INPUT_BYTES)
+            throw new Error("系统操作 JSON 超过 1 MiB。");
+        chunks.push(bytes);
+    }
+    const value = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("需要 JSON 对象。");
+    return value;
+}
+function fields(body, allowed) {
+    for (const key of Object.keys(body))
+        if (!allowed.includes(key))
+            throw new Error(`不支持字段：${key}`);
+}
+function requiredText(value, field) {
+    if (typeof value !== "string" || !value.trim())
+        throw new Error(`缺少 ${field}。`);
+    return value;
+}
+/** Parse before opening config/authentication; never retries mutations or accepts arbitrary API paths. */
+export async function parseSystemCliCommand(command, args, input = process.stdin) {
+    const reads = {
+        "employee:list": "/api/silicon-employees",
+        "workspace:list": "/api/workspaces",
+        "schedule:list": "/api/scheduled-tasks",
+    };
+    if (reads[command]) {
+        const flag = command === "employee:list" ? "--include-archived" : command === "schedule:list" ? "--include-cancelled" : null;
+        if (args.length && !(flag && args.length === 1 && args[0] === flag))
+            throw new Error(`用法：wand ${command}${flag ? ` [${flag}]` : ""}`);
+        const query = args.length ? (command === "employee:list" ? "?includeArchived=1" : "?includeCancelled=1") : "";
+        return api => api.get(reads[command] + query);
+    }
+    if (command === "schedule:read") {
+        if (args.length !== 1 || !args[0] || args[0].startsWith("-"))
+            throw new Error("用法：wand schedule:read <id>");
+        return api => api.get(`/api/scheduled-tasks/${encodeURIComponent(args[0])}`);
+    }
+    const withId = command === "schedule:update" || command === "session:resume";
+    const id = withId ? args[0] : undefined;
+    if ((withId && (!id || id.startsWith("-"))) || args.length !== (withId ? 2 : 1) || args.at(-1) !== "--stdin") {
+        throw new Error(`用法：wand ${command}${withId ? " <id>" : ""} --stdin`);
+    }
+    const body = await jsonInput(input);
+    if (command === "session:create") {
+        fields(body, ["employeeId", "workspaceId", "cwd", "prompt"]);
+        requiredText(body.employeeId, "employeeId（先查询员工列表）");
+        // Employee's configured provider, model, role and permissions remain authoritative.
+        return api => api.post("/api/structured-sessions", { ...body, respondImmediately: true });
+    }
+    if (command === "schedule:create") {
+        fields(body, ["requestId", "employeeId", "workspaceId", "title", "prompt", "schedule"]);
+        requiredText(body.requestId, "requestId（保存后复用，不要重建）");
+        requiredText(body.employeeId, "employeeId");
+        requiredText(body.prompt, "prompt");
+        return api => api.post("/api/scheduled-tasks", body);
+    }
+    if (command === "schedule:update") {
+        fields(body, ["revision", "employeeId", "workspaceId", "title", "prompt", "schedule", "enabled", "cancelled"]);
+        if (!Number.isInteger(body.revision) || Number(body.revision) < 1)
+            throw new Error("需要当前 revision。");
+        return api => api.patch(`/api/scheduled-tasks/${encodeURIComponent(id)}`, body);
+    }
+    if (command === "session:resume") {
+        fields(body, ["input"]);
+        requiredText(body.input, "input（检查证据及明确的续接要求）");
+        return async (api) => {
+            const route = `/api/sessions/${encodeURIComponent(id)}`;
+            const snapshot = await api.get(route);
+            if (snapshot.id !== id)
+                throw new Error("会话 ID 不匹配，未续接。");
+            if (snapshot.structuredState?.inFlight || snapshot.ptyCommandRunning || snapshot.ptyBusy
+                || snapshot.permissionBlocked || snapshot.pendingEscalation || snapshot.queuedMessages?.length) {
+                throw new Error("目标会话仍在执行、等待审批或有排队消息；未打断或重复唤起，请核对。");
+            }
+            if (snapshot.sessionKind !== "structured") {
+                throw new Error("此入口仅续接 Wand 结构化会话；PTY 请通过原终端恢复，不能冒充已恢复。");
+            }
+            if (snapshot.archived)
+                await api.post(`${route}/unarchive`, {});
+            // Managed structured sessions resume their native history through the existing input owner.
+            return api.post(`${route}/input`, { input: body.input, respondImmediately: true });
+        };
+    }
+    throw new Error("未知系统操作。");
+}

package/dist/system-skill.d.ts

@@ -0,0 +1,5 @@
+import { type SessionProvider } from "./provider-catalog.js";
+export declare function installSystemSkill(configPath: string, providers?: readonly SessionProvider[], home?: string): Promise<{
+    installed: string[];
+    providers: readonly SessionProvider[];
+}>;

package/dist/system-skill.js

@@ -0,0 +1,19 @@
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { installManagedSkill } from "./managed-skill.js";
+import { SESSION_PROVIDERS } from "./provider-catalog.js";
+export async function installSystemSkill(configPath, providers = SESSION_PROVIDERS, home = homedir()) {
+    const source = fileURLToPath(new URL("../skills/wand-system/", import.meta.url));
+    const files = Object.fromEntries(await Promise.all(["SKILL.md", "references/operations.md", "scripts/wand.mjs"].map(async (file) => [file, await readFile(path.join(source, file), "utf8")])));
+    const js = fileURLToPath(new URL("./cli.js", import.meta.url));
+    const cli = existsSync(js) ? js : js.replace(/\.js$/, ".ts");
+    // Only local executable/config paths, never an admin password or capability token.
+    files[".runtime.json"] = JSON.stringify({
+        node: process.execPath, cli, config: path.resolve(configPath),
+        ...(cli.endsWith(".ts") ? { loader: import.meta.resolve("tsx") } : {}),
+    });
+    return installManagedSkill(path.dirname(configPath), "wand-system", files, providers, home);
+}

package/dist/task-organize-contract.js

@@ -1,4 +1,4 @@
 export const TASK_ORGANIZE_OPTIONS = [
-    { value: "auto", label: "自动任务归类", hint: "仅系统自动标题，跳过用户自定标题" },
-    { value: "all", label: "所有任务归类", hint: "包含用户自定标题的任务" },
+    { value: "auto", label: "默认范围会话", hint: "未分组及系统自动任务中的工作会话；不挪动人工命名任务中的会话" },
+    { value: "all", label: "所有工作会话", hint: "包含人工任务中的会话；仍跳过归档、私聊、自动化执行和系统日志" },
 ];

package/dist/task-title-organize-service.d.ts

@@ -4,7 +4,7 @@ import { type TitleJudge } from "./task-title-organize.js";
 import type { WandStorage } from "./storage.js";
 import type { OrganizeByTitleResult } from "./task-organize-contract.js";
 export type { OrganizeByTitleResult } from "./task-organize-contract.js";
-export declare function titleJudgeForStorage(storage: WandStorage, options: AutoTaskTitleOptions): TitleJudge | undefined;
+export declare function titleJudgeForStorage(storage: WandStorage, options: AutoTaskTitleOptions, onCallSessionCreated?: (id: string) => void): TitleJudge | undefined;
 export declare function systemTitleJudge(ai: QuickCommitAiOptions, cwd: string): TitleJudge;
 /**
  * Classify the selected tasks by title and move in-scope sessions to the task

package/dist/task-title-organize-service.js

@@ -1,10 +1,11 @@
 import { callConfiguredAiText } from "./ai-text-runner.js";
 import { getErrorMessage } from "./error-utils.js";
+import { isSystemAiCall } from "./system-ai-call.js";
 import { resolveSystemAiContext } from "./session-ai-context.js";
 import { parentTaskIdFrom } from "./task-agent-parsing.js";
 import { planTitleOrganization, parseTitleJudgment, titleJudgmentPrompt, } from "./task-title-organize.js";
 import { isGlobalWorkspace, normalizeProjectCwd, projectCwdForSession } from "./workspace-binding.js";
-export function titleJudgeForStorage(storage, options) {
+export function titleJudgeForStorage(storage, options, onCallSessionCreated) {
     const config = options.config;
     if (!config)
         return undefined;
@@ -16,16 +17,15 @@ export function titleJudgeForStorage(storage, options) {
         command: provider === "qoder" ? "qodercli" : (provider || "pi"),
         selectedModel: null,
         thinkingEffort: "off",
-    }, config, storage.getSystemSiliconEmployee(), options.free);
-    if (ai.employeeChannelOnly && !ai.cliCandidates?.length)
-        return undefined;
-    return systemTitleJudge(ai, options.cwd || config.defaultCwd || process.cwd());
+    }, config, storage.getSystemSiliconEmployee(), options.free, { storage });
+    return systemTitleJudge({ ...ai, onCallSessionCreated }, options.cwd || config.defaultCwd || process.cwd());
 }
 export function systemTitleJudge(ai, cwd) {
     return async (input) => {
         const request = titleJudgmentPrompt(input);
         return callConfiguredAiText(request, cwd || process.cwd(), "", {
             ...ai,
+            purpose: "task-organize",
             thinkingEffort: "off",
         }, parseTitleJudgment);
     };
@@ -94,6 +94,8 @@ export async function organizeSelectedByTitle(storage, input, options = {}) {
     const sessions = new Map();
     for (const task of tasks) {
         for (const session of storage.listSessionsByWorkspaceTaskSlim(task.id)) {
+            if (isSystemAiCall(session))
+                continue;
             sessions.set(session.id, sessionRecord(session, teamIds.has(session.id)));
         }
     }
@@ -105,6 +107,8 @@ export async function organizeSelectedByTitle(storage, input, options = {}) {
             refused.push({ id, kind: "session", reason: "未找到该会话" });
             continue;
         }
+        if (isSystemAiCall(session))
+            continue;
         // Explicit session selection must not pull user-named tasks into auto mode.
         if ((input.mode ?? "auto") === "auto" && session.workspaceTaskId
             && storage.getWandTaskByWorkspaceTaskId(session.workspaceTaskId)?.titleSource !== "auto")

package/dist/task-title-organize.js

@@ -14,8 +14,11 @@ const PLACEHOLDER_TITLES = new Set([
     "pi",
 ]);
 export function titleIdentity(title) {
+    // Symbols and inner punctuation can carry identity (C++ / C#, 1.0 / 10).
+    // Only ignore spacing, case and terminal sentence marks; other differences need judgment.
     return title.normalize("NFKC")
-        .replace(/[\p{P}\p{S}]+/gu, " ")
+        .trim()
+        .replace(/[。.!！?？]+$/u, "")
         .replace(/\s+/g, "")
         .toLowerCase();
 }
@@ -24,9 +27,11 @@ export function isClassifiableTitle(title) {
     if (trimmed.length < 2 || trimmed === "未命名任务" || trimmed === "新任务")
         return false;
     const identity = titleIdentity(trimmed);
-    if (!identity || PLACEHOLDER_TITLES.has(identity))
+    // Placeholder recognition retains old formatting tolerance without using this lossy key for grouping.
+    const placeholderIdentity = identity.replace(/[\p{P}\p{S}]+/gu, "");
+    if (!placeholderIdentity || PLACEHOLDER_TITLES.has(placeholderIdentity))
         return false;
-    if (/^(?:claude|codex|opencode|grok|qoder|pi|终端)\d+$/i.test(identity))
+    if (/^(?:claude|codex|opencode|grok|qoder|pi|终端)\d+$/i.test(placeholderIdentity))
         return false;
     return true;
 }
@@ -263,7 +268,8 @@ export async function planTitleOrganization(tasks, sessions, judge) {
         const task = byId.get(id);
         if (!task)
             return [];
-        const hasPeer = targets.some((peer) => peer.id !== task.id && peer.workspaceId === task.workspaceId && peer.status === "doing");
+        const hasPeer = targets.some((peer) => peer.id !== task.id && peer.workspaceId === task.workspaceId
+            && sameDirectory(peer.directoryKey, task.directoryKey) && peer.status === "doing");
         return hasPeer ? [task] : [];
     });
     const judgeNeeded = judgeSessions.length > 0 || judgeTasks.length > 0;
@@ -274,7 +280,8 @@ export async function planTitleOrganization(tasks, sessions, judge) {
         let judgment;
         try {
             judgment = await judgeTitleOrganization({
-                tasks: targets.filter((task) => judgeTasks.some((item) => item.workspaceId === task.workspaceId) || judgeSessions.some((session) => sameDirectory(session.directoryKey, task.directoryKey)))
+                tasks: targets.filter((task) => judgeTasks.some((item) => item.workspaceId === task.workspaceId && sameDirectory(item.directoryKey, task.directoryKey))
+                    || judgeSessions.some((session) => sameDirectory(session.directoryKey, task.directoryKey)))
                     .map((task) => ({ id: task.id, titles: classifiableTitles(task.titles) })),
                 sessions: judgeSessions.map((session) => ({ id: session.id, title: session.title.trim() })),
             }, judge);
@@ -307,7 +314,7 @@ export async function planTitleOrganization(tasks, sessions, judge) {
             if (!parentWorkspaceTaskId || parentWorkspaceTaskId === task.id)
                 continue;
             const parent = byId.get(parentWorkspaceTaskId);
-            if (!parent || parent.workspaceId !== task.workspaceId || parent.status !== "doing") {
+            if (!parent || parent.workspaceId !== task.workspaceId || !sameDirectory(parent.directoryKey, task.directoryKey) || parent.status !== "doing") {
                 if (parentWorkspaceTaskId)
                     refused.push({ id: task.id, kind: "task", reason: "不能归入该任务" });
                 continue;

package/dist/task-title-service.js

@@ -68,7 +68,7 @@ export class TaskTitleService {
                 const provider = config?.defaultProvider ?? "claude";
                 const ai = config ? resolveSystemAiContext({ provider, structuredState: undefined, runner: undefined,
                     command: provider === "qoder" ? "qodercli" : provider, selectedModel: null,
-                    thinkingEffort: config.defaultThinkingEffort }, config, this.storage.getSystemSiliconEmployee(), free) : {};
+                    thinkingEffort: config.defaultThinkingEffort }, config, this.storage.getSystemSiliconEmployee(), free, { storage: this.storage }) : {};
                 const cwd = (current.workspaceId ? this.storage.getWorkspace(current.workspaceId)?.cwd : undefined) || this.options.cwd
                     || config?.defaultCwd || process.cwd();
                 const title = await generateTitle(input.source, cwd, config?.language ?? "", { ...ai, signal: this.controller.signal });

package/dist/task-title.js

@@ -78,7 +78,7 @@ export async function generateWandTaskTitle(description, cwd, language = "", ai
         ].join("\n"),
         prompt: `任务描述：\n${input}`,
     };
-    return callConfiguredAiText(request, cwd || process.cwd(), language, ai, (raw) => {
+    return callConfiguredAiText(request, cwd || process.cwd(), language, { ...ai, purpose: "task-title" }, (raw) => {
         const stripped = stripGeneratedTitle(raw);
         // 校验在候选链内：格式不可用也要继续备用候选，不能先把非空文本当成功。
         // 先判可信度再裁剪：截断过的长句看起来就像标题，会绕过长度检查。

package/dist/user-memory.js

@@ -160,7 +160,7 @@ export class UserMemoryService {
             }, config.defaultCwd, config.language ?? "", resolveSystemAiContext({
                 provider: config.defaultProvider ?? "claude", command: config.defaultProvider ?? "claude",
                 selectedModel: null, thinkingEffort: config.defaultThinkingEffort,
-            }, config, storage.getSystemSiliconEmployee(), this.deps.free), (raw) => parseUserMemoryPreferences(raw, events));
+            }, config, storage.getSystemSiliconEmployee(), this.deps.free, { storage, purpose: "user-memory" }), (raw) => parseUserMemoryPreferences(raw, events));
         // Test seam and production share the exact same validator.
         const validated = parseUserMemoryPreferences(JSON.stringify({ preferences }), events);
         const referenced = new Set(validated.flatMap((entry) => entry.evidenceIds));

package/dist/wand-task-sync.js

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { isSystemAiCall } from "./system-ai-call.js";
 import { isSessionProvider } from "./session-provider.js";
 import { provisionalTaskTitleFromDescription } from "./task-title.js";
 /** 未命名任务的占位名；服务端新建时写入，自动命名成功后被真实标题覆盖。 */
@@ -43,7 +44,7 @@ export function isAutoNameableBoardTask(card) {
 function taskNamingSessions(storage, card) {
     const sessions = new Map();
     const add = (session) => {
-        if (session && !sessions.has(session.id))
+        if (session && !isSystemAiCall(session) && !sessions.has(session.id))
             sessions.set(session.id, session);
     };
     const needsMessageFallback = [];