@co0ontty/wand 4.94.0 → 4.95.0

package/dist/employee-im-types.d.ts

@@ -0,0 +1,80 @@
+/** Shared employee IM configuration contract. Credentials are write-only. */
+export declare const EMPLOYEE_IM_EVENTS: readonly [{
+    readonly value: "task_started";
+    readonly label: "开始处理任务";
+}, {
+    readonly value: "task_completed";
+    readonly label: "任务完成";
+}, {
+    readonly value: "task_failed";
+    readonly label: "任务失败";
+}, {
+    readonly value: "task_stopped";
+    readonly label: "任务停止";
+}, {
+    readonly value: "waiting_permission";
+    readonly label: "等待权限或计划审批";
+}, {
+    readonly value: "waiting_input";
+    readonly label: "等待用户输入";
+}, {
+    readonly value: "message_queued";
+    readonly label: "消息进入队列";
+}, {
+    readonly value: "step_completed";
+    readonly label: "步骤完成";
+}, {
+    readonly value: "candidate_switched";
+    readonly label: "执行候选切换";
+}, {
+    readonly value: "team_started";
+    readonly label: "团队开始任务";
+}, {
+    readonly value: "team_completed";
+    readonly label: "团队任务完成";
+}, {
+    readonly value: "team_failed";
+    readonly label: "团队任务失败";
+}, {
+    readonly value: "team_stopped";
+    readonly label: "团队任务停止";
+}];
+export type EmployeeImEvent = typeof EMPLOYEE_IM_EVENTS[number]["value"];
+export type EmployeeImProvider = "telegram" | "dingtalk";
+/** Shared notification choices; selected events go to every enabled channel for this employee. */
+export declare const EMPLOYEE_IM_EVENT_GROUPS: ReadonlyArray<{
+    label: string;
+    events: readonly EmployeeImEvent[];
+}>;
+export declare const EMPLOYEE_IM_PRIMARY_EVENTS: readonly EmployeeImEvent[];
+export declare const EMPLOYEE_IM_MORE_EVENT_GROUPS: {
+    events: ("task_started" | "task_completed" | "task_failed" | "task_stopped" | "waiting_permission" | "waiting_input" | "message_queued" | "step_completed" | "candidate_switched" | "team_started" | "team_completed" | "team_failed" | "team_stopped")[];
+    label: string;
+}[];
+export interface EmployeeImChannel {
+    enabled: boolean;
+    /** Telegram destination; not a credential. */
+    chatId?: string;
+    botTokenConfigured?: boolean;
+    webhookConfigured?: boolean;
+    secretConfigured?: boolean;
+}
+export interface EmployeeImConfig {
+    events: EmployeeImEvent[];
+    telegram: EmployeeImChannel;
+    dingtalk: EmployeeImChannel;
+}
+export interface EmployeeImChannelInput {
+    enabled: boolean;
+    chatId?: string;
+    /** undefined/empty preserves an existing credential; null explicitly clears it. */
+    botToken?: string | null;
+    webhook?: string | null;
+    secret?: string | null;
+}
+export interface EmployeeImConfigInput {
+    events: EmployeeImEvent[];
+    telegram: EmployeeImChannelInput;
+    dingtalk: EmployeeImChannelInput;
+}
+export declare function emptyEmployeeImConfig(): EmployeeImConfig;

package/dist/employee-im-types.js

@@ -0,0 +1,32 @@
+/** Shared employee IM configuration contract. Credentials are write-only. */
+export const EMPLOYEE_IM_EVENTS = [
+    { value: "task_started", label: "开始处理任务" },
+    { value: "task_completed", label: "任务完成" },
+    { value: "task_failed", label: "任务失败" },
+    { value: "task_stopped", label: "任务停止" },
+    { value: "waiting_permission", label: "等待权限或计划审批" },
+    { value: "waiting_input", label: "等待用户输入" },
+    { value: "message_queued", label: "消息进入队列" },
+    { value: "step_completed", label: "步骤完成" },
+    { value: "candidate_switched", label: "执行候选切换" },
+    { value: "team_started", label: "团队开始任务" },
+    { value: "team_completed", label: "团队任务完成" },
+    { value: "team_failed", label: "团队任务失败" },
+    { value: "team_stopped", label: "团队任务停止" },
+];
+/** Shared notification choices; selected events go to every enabled channel for this employee. */
+export const EMPLOYEE_IM_EVENT_GROUPS = [
+    { label: "处理进度", events: ["task_started", "message_queued", "step_completed", "candidate_switched"] },
+    { label: "需要你介入", events: ["waiting_permission", "waiting_input"] },
+    { label: "执行结果", events: ["task_completed", "task_failed", "task_stopped"] },
+    { label: "团队任务", events: ["team_started", "team_completed", "team_failed", "team_stopped"] },
+];
+export const EMPLOYEE_IM_PRIMARY_EVENTS = [
+    "task_started", "task_completed", "task_failed", "task_stopped", "waiting_permission", "waiting_input",
+];
+export const EMPLOYEE_IM_MORE_EVENT_GROUPS = EMPLOYEE_IM_EVENT_GROUPS
+    .map(group => ({ ...group, events: group.events.filter(event => !EMPLOYEE_IM_PRIMARY_EVENTS.includes(event)) }))
+    .filter(group => group.events.length > 0);
+export function emptyEmployeeImConfig() {
+    return { events: [], telegram: { enabled: false, chatId: "" }, dingtalk: { enabled: false } };
+}

package/dist/employee-im.d.ts

@@ -0,0 +1,35 @@
+import { type EmployeeImEvent, type EmployeeImProvider } from "./employee-im-types.js";
+import type { WandStorage } from "./storage.js";
+interface Notice {
+    employeeId: string;
+    provider: EmployeeImProvider;
+    event: EmployeeImEvent;
+    context: {
+        sessionId?: string;
+        title?: string;
+    };
+}
+interface EmployeeImOptions {
+    fetch?: typeof fetch;
+    timeoutMs?: number;
+    now?: () => number;
+    onFailure?: () => void;
+}
+/** Best-effort, bounded and non-blocking. No automatic retry after an unknown delivery. */
+export declare class EmployeeImService {
+    private readonly storage;
+    private readonly options;
+    private readonly queue;
+    private readonly controllers;
+    private active;
+    private disposed;
+    constructor(storage: WandStorage, options?: EmployeeImOptions);
+    notify(employeeId: string, event: EmployeeImEvent, context?: Notice["context"]): void;
+    test(employeeId: string, provider: EmployeeImProvider): Promise<void>;
+    dispose(): void;
+    private failure;
+    private pump;
+    private sendNotice;
+    private deliver;
+}
+export {};

package/dist/employee-im.js

@@ -0,0 +1,157 @@
+import { createHmac } from "node:crypto";
+import { dingTalkWebhook } from "./employee-im-config.js";
+import { EMPLOYEE_IM_EVENTS } from "./employee-im-types.js";
+/** Best-effort, bounded and non-blocking. No automatic retry after an unknown delivery. */
+export class EmployeeImService {
+    storage;
+    options;
+    queue = [];
+    controllers = new Set();
+    active = 0;
+    disposed = false;
+    constructor(storage, options = {}) {
+        this.storage = storage;
+        this.options = options;
+    }
+    notify(employeeId, event, context = {}) {
+        if (this.disposed)
+            return;
+        try {
+            const employee = this.storage.getSiliconEmployeeDefinition(employeeId);
+            if (!employee || employee.archivedAt)
+                return;
+            const config = this.storage.getEmployeeImConfig(employeeId);
+            if (!config.events.includes(event))
+                return;
+            for (const provider of ["telegram", "dingtalk"]) {
+                if (!config[provider].enabled)
+                    continue;
+                if (this.queue.length >= 100) {
+                    this.failure();
+                    continue;
+                }
+                this.queue.push({ employeeId, provider, event, context: { sessionId: context.sessionId, title: context.title?.slice(0, 200) } });
+            }
+            this.pump();
+        }
+        catch {
+            this.failure();
+        }
+    }
+    async test(employeeId, provider) {
+        if (this.disposed || this.active >= 4)
+            throw new Error("IM 发送繁忙，请稍后重试。");
+        this.active += 1;
+        try {
+            await this.deliver(employeeId, provider, "Wand · IM 测试通知\n此员工的消息渠道已连通。");
+        }
+        finally {
+            this.active -= 1;
+            this.pump();
+        }
+    }
+    dispose() {
+        this.disposed = true;
+        this.queue.length = 0;
+        for (const controller of this.controllers)
+            controller.abort();
+        this.controllers.clear();
+    }
+    failure() {
+        try {
+            this.options.onFailure?.();
+        }
+        catch { /* observers cannot affect execution */ }
+    }
+    pump() {
+        while (!this.disposed && this.active < 4 && this.queue.length) {
+            const item = this.queue.shift();
+            this.active += 1;
+            void this.sendNotice(item).catch(() => this.failure()).finally(() => { this.active -= 1; this.pump(); });
+        }
+    }
+    async sendNotice(item) {
+        // Re-read before delivery: queued notices cannot survive disable/archive/delete or a changed selection.
+        const employee = this.storage.getSiliconEmployeeDefinition(item.employeeId);
+        const config = this.storage.getEmployeeImConfig(item.employeeId);
+        if (!employee || employee.archivedAt || !config[item.provider].enabled || !config.events.includes(item.event))
+            return;
+        const label = EMPLOYEE_IM_EVENTS.find(event => event.value === item.event)?.label;
+        if (!label)
+            return;
+        const lines = [`Wand · ${label}`, `员工：${employee.name.slice(0, 40)}`, `任务：${item.context.title || "员工任务"}`];
+        if (item.context.sessionId)
+            lines.push(`会话：${item.context.sessionId.slice(0, 100)}`);
+        await this.deliver(item.employeeId, item.provider, lines.join("\n").slice(0, 3000));
+    }
+    async deliver(employeeId, provider, text) {
+        if (!this.storage.getSiliconEmployeeDefinition(employeeId))
+            throw new Error("员工不存在。");
+        const { config, credentials } = this.storage.getEmployeeImSettings(employeeId);
+        let url;
+        let body;
+        if (provider === "telegram") {
+            if (!credentials.botToken || !config.telegram.chatId)
+                throw new Error("请先保存 Telegram Bot Token 和 Chat ID。");
+            url = new URL(`https://api.telegram.org/bot${credentials.botToken}/sendMessage`);
+            body = { chat_id: config.telegram.chatId, text };
+        }
+        else {
+            if (!credentials.webhook)
+                throw new Error("请先保存钉钉机器人 Webhook。");
+            url = dingTalkWebhook(credentials.webhook);
+            if (credentials.secret) {
+                const timestamp = String((this.options.now ?? Date.now)());
+                const sign = createHmac("sha256", credentials.secret).update(`${timestamp}\n${credentials.secret}`).digest("base64");
+                url.searchParams.set("timestamp", timestamp);
+                url.searchParams.set("sign", sign);
+            }
+            body = { msgtype: "text", text: { content: text } };
+        }
+        const controller = new AbortController();
+        this.controllers.add(controller);
+        const timer = setTimeout(() => controller.abort(), this.options.timeoutMs ?? 8000);
+        timer.unref?.();
+        try {
+            const response = await (this.options.fetch ?? fetch)(url, {
+                method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body),
+                redirect: "error", signal: controller.signal,
+            });
+            if (!response.ok) {
+                await response.body?.cancel();
+                throw new Error("IM 发送失败，请检查机器人凭据、接收目标及网络。");
+            }
+            const reader = response.body?.getReader();
+            if (!reader)
+                throw new Error("IM 服务未返回有效回执。");
+            const chunks = [];
+            let size = 0;
+            try {
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    size += value.byteLength;
+                    if (size > 16_384)
+                        throw new Error("IM 回执过大。");
+                    chunks.push(value);
+                }
+            }
+            finally {
+                await reader.cancel().catch(() => { });
+                reader.releaseLock();
+            }
+            const payload = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+            if (provider === "telegram" ? payload.ok !== true : payload.errcode !== 0)
+                throw new Error("IM 服务拒绝了消息。");
+        }
+        catch {
+            // Provider bodies and errors may include the credential-bearing request URL: never echo/log them.
+            throw new Error("IM 发送未确认，请检查机器人凭据、接收目标及网络；不会自动重发。");
+        }
+        finally {
+            clearTimeout(timer);
+            this.controllers.delete(controller);
+        }
+    }
+}

package/dist/employee-knowledge.js

@@ -51,7 +51,8 @@ export function rememberExplicitEmployeeRequest(storage, employeeId, prompt) {
 export function startEmployeeKnowledgeRunner(storage, runner, context, observer) {
     const employeeId = context.session.employeeId;
     // Strip any inherited credentials from the parent environment (including nested Wand runs).
-    const env = { ...context.env };
+    // Non-secret identity, overwritten for nested executions; never infer a current session by title/time.
+    const env = { ...context.env, WAND_SESSION_ID: context.session.id };
     delete env.WAND_KNOWLEDGE_DB;
     delete env.WAND_KNOWLEDGE_TOKEN;
     if (!employeeId)
@@ -69,7 +70,7 @@ export function startEmployeeKnowledgeRunner(storage, runner, context, observer)
     try {
         const receipt = (!context.session.automationId || context.session.automationId.startsWith("wand-task:"))
             ? rememberExplicitEmployeeRequest(storage, employeeId, context.prompt) : null;
-        const runtimeSystemPrompt = [context.session.runtimeSystemPrompt, receipt, knowledgeContext(storage, employeeId, context.prompt)]
+        const runtimeSystemPrompt = [context.session.runtimeSystemPrompt, `当前 Wand 会话 ID：${context.session.id}（非凭据；创建后续检查计划时用作精确续接目标）。`, receipt, knowledgeContext(storage, employeeId, context.prompt)]
             .filter(Boolean).join("\n\n");
         const execution = runner.start({ ...context,
             session: { ...context.session, runtimeSystemPrompt },

package/dist/employee-text.d.ts

@@ -13,6 +13,7 @@ export interface EmployeeTextDeps {
         outputTokens: number;
         model: string;
     }) => void;
+    callSessionId?: string;
 }
 /** Expand each configured slot once; equivalent leaves execute once in first occurrence order. */
 export declare function employeeTextCandidates(agents: readonly WandTaskAgent[], config: Parameters<typeof getDefaultModelForProvider>[0] & Pick<WandConfig, "modelGroups">): Array<{

package/dist/employee-text.js

@@ -1,4 +1,6 @@
 import { coreHarnessRuntime, loadPiAi, resolveCoreModel } from "./harness-engine.js";
+import { randomUUID } from "node:crypto";
+import { CoreTurnTracker } from "./core-turn-tracker.js";
 import { agentKey } from "./ai-team-types.js";
 import { getDefaultModelForProvider } from "./config.js";
 import { freeModelOrder, resolveModelGroupModels } from "./model-groups.js";
@@ -84,6 +86,7 @@ export async function prepareEmployeeTextCandidate(deps, agent, request, signal)
     }
     if (agent.provider !== "pi")
         throw new Error("Wand Agent只支持Pi provider。");
+    CoreTurnTracker.assertSystemCallAdmission();
     const pi = await loadPiAi();
     const context = pi.normalizeContext({ systemPrompt: request.system,
         messages: [{ role: "user", content: request.prompt, timestamp: Date.now() }], tools: [] });
@@ -96,14 +99,20 @@ export async function prepareEmployeeTextCandidate(deps, agent, request, signal)
         const { streamSimple } = await import("@earendil-works/pi-ai/api/openai-completions");
         return async () => {
             signal.throwIfAborted();
-            let status;
-            const message = await streamSimple(checked.model, context, { apiKey: checked.apiKey, signal,
-                maxRetries: 0, fetch: async (input, init) => { const response = await fetch(input, init); status = response.status; return response; },
-                maxTokens: Math.min(4096, checked.model.maxTokens), reasoning: reasoning === "off" ? undefined : reasoning,
-                toolChoice: "none", onPayload: payload => ({ ...payload, provider: OPENROUTER_FREE_ROUTING }) }).result();
-            const text = sdkText(message, status);
-            deps.onUsage?.({ inputTokens: message.usage.input, outputTokens: message.usage.output, model: `${checked.model.provider}/${checked.model.id}` });
-            return text;
+            const token = CoreTurnTracker.startTurn(deps.callSessionId ?? `system-ai:${randomUUID()}`, true);
+            try {
+                let status;
+                const message = await streamSimple(checked.model, context, { apiKey: checked.apiKey, signal,
+                    maxRetries: 0, fetch: async (input, init) => { const response = await fetch(input, init); status = response.status; return response; },
+                    maxTokens: Math.min(4096, checked.model.maxTokens), reasoning: reasoning === "off" ? undefined : reasoning,
+                    toolChoice: "none", onPayload: payload => ({ ...payload, provider: OPENROUTER_FREE_ROUTING }) }).result();
+                const text = sdkText(message, status);
+                deps.onUsage?.({ inputTokens: message.usage.input, outputTokens: message.usage.output, model: `${checked.model.provider}/${checked.model.id}` });
+                return text;
+            }
+            finally {
+                CoreTurnTracker.endTurn(token);
+            }
         };
     }
     const resolved = await resolveCoreModel(config.harness, agent.model, { cwd: config.defaultCwd });
@@ -113,10 +122,16 @@ export async function prepareEmployeeTextCandidate(deps, agent, request, signal)
     const level = pi.clampThinkingLevel(resolved.model, (reasoning ?? "off"));
     return async () => {
         signal.throwIfAborted();
-        const message = await runtime.streamSimple(resolved.model, context, { signal, maxRetries: 0, maxTokens: Math.min(4096, resolved.model.maxTokens),
-            reasoning: level === "off" ? undefined : level, toolChoice: "none" }).result();
-        const text = sdkText(message);
-        deps.onUsage?.({ inputTokens: message.usage.input, outputTokens: message.usage.output, model: `${resolved.model.provider}/${resolved.model.id}` });
-        return text;
+        const token = CoreTurnTracker.startTurn(deps.callSessionId ?? `system-ai:${randomUUID()}`, true);
+        try {
+            const message = await runtime.streamSimple(resolved.model, context, { signal, maxRetries: 0, maxTokens: Math.min(4096, resolved.model.maxTokens),
+                reasoning: level === "off" ? undefined : level, toolChoice: "none" }).result();
+            const text = sdkText(message);
+            deps.onUsage?.({ inputTokens: message.usage.input, outputTokens: message.usage.output, model: `${resolved.model.provider}/${resolved.model.id}` });
+            return text;
+        }
+        finally {
+            CoreTurnTracker.endTurn(token);
+        }
     };
 }

package/dist/git-quick-commit.js

@@ -354,7 +354,7 @@ function commitTaskLine(lang, usedIteration) {
 async function generateCommitMessage(cwd, language, ai = {}, options = {}) {
     const { input, usedIteration } = await buildCommitPromptInput(cwd, options);
     const lang = language.trim() || "中文";
-    return callConfiguredAiText({ system: commitTaskLine(lang, usedIteration), prompt: input }, cwd, language, ai, (raw) => {
+    return callConfiguredAiText({ system: commitTaskLine(lang, usedIteration), prompt: input }, cwd, language, { ...ai, purpose: "git-commit" }, (raw) => {
         const message = normalizeAiText(raw);
         if (!message)
             throw new QuickCommitError("AI 返回了空的 commit message。", "EMPTY_AI_MESSAGE");
@@ -407,7 +407,7 @@ async function generateCommitMessageWithTag(cwd, language, ai = {}, options = {}
 
 请严格输出**单行 JSON 对象**，不要 Markdown 代码块、不要任何解释文字、不要多余引号。格式：
 {"message":"...","tag":"v1.2.3"}`;
-    return callConfiguredAiText({ system, prompt: `${tagHint}\n\n${input}` }, cwd, language, ai, (raw) => {
+    return callConfiguredAiText({ system, prompt: `${tagHint}\n\n${input}` }, cwd, language, { ...ai, purpose: "git-tag" }, (raw) => {
         const parsed = tryParseJson(raw);
         // Preserve the plain-message fallback for older CLIs that do not return JSON.
         const message = normalizeAiText(parsed && typeof parsed.message === "string" ? parsed.message : raw);
@@ -464,7 +464,7 @@ async function generateTagAfterCommit(cwd, language, commitMessage, ai = {}) {
 请用${lang}思考但严格输出**单行 JSON 对象**，不要 Markdown 代码块、不要任何解释文字、不要多余引号。格式：
 {"tag":"v1.2.3"}`;
     const prompt = `${tagHint}\n\ncommit message：${commitMessage}\n\ngit diff：\n${diff}`;
-    return callConfiguredAiText({ system, prompt }, cwd, language, ai, (raw) => {
+    return callConfiguredAiText({ system, prompt }, cwd, language, { ...ai, purpose: "git-tag" }, (raw) => {
         const parsed = tryParseJson(raw);
         const suggested = sanitizeSuggestedTag(parsed && typeof parsed.tag === "string" ? parsed.tag : raw);
         if (!suggested)
@@ -875,6 +875,24 @@ async function getLatestTagAtHead(cwd) {
     }
 }
 async function runQuickCommitFallbackCli(opts, priorError) {
+    const trace = opts.traceFactory?.start("git-fallback", buildFallbackPrompt(opts, priorError), opts.cwd);
+    const candidate = { provider: defaultProvider(opts.provider), engine: "cli", model: opts.model ?? undefined, thinkingEffort: opts.thinkingEffort ?? undefined };
+    try {
+        if (trace)
+            opts.onCallSessionCreated?.(trace.sessionId);
+        trace?.candidateStarted(candidate);
+        const result = await runQuickCommitFallbackCliImpl(opts, priorError);
+        trace?.applicationResult(result);
+        trace?.complete();
+        return result;
+    }
+    catch (error) {
+        trace?.candidateFailed(candidate, error, "execution");
+        trace?.fail(error);
+        throw error;
+    }
+}
+async function runQuickCommitFallbackCliImpl(opts, priorError) {
     await assertGitWorkTreeAsync(opts.cwd);
     const beforeHead = await getHead(opts.cwd);
     const request = withOpsPersona(buildFallbackPrompt(opts, priorError), opts.opsPersona);

package/dist/managed-skill.d.ts

@@ -0,0 +1,6 @@
+import { type SessionProvider } from "./provider-catalog.js";
+/** Install trusted bundled files without overwriting user content or changing tool permissions. */
+export declare function installManagedSkill(configDir: string, name: string, files: Record<string, string>, providers?: readonly SessionProvider[], home?: string): Promise<{
+    installed: string[];
+    providers: readonly SessionProvider[];
+}>;

package/dist/managed-skill.js

@@ -0,0 +1,99 @@
+import { createHash } from "node:crypto";
+import { readFile, mkdir, lstat, readlink, writeFile, symlink, realpath } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import { SESSION_PROVIDERS } from "./provider-catalog.js";
+const sha = (data) => createHash("sha256").update(data).digest("hex");
+/** Install trusted bundled files without overwriting user content or changing tool permissions. */
+export async function installManagedSkill(configDir, name, files, providers = SESSION_PROVIDERS, home = homedir()) {
+    if (!providers.length || providers.some((provider) => !SESSION_PROVIDERS.includes(provider)))
+        throw new Error("未知CLI技能目标。");
+    if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(name) || Object.keys(files).some(file => path.isAbsolute(file) || file.split(/[\\/]/).some(part => !part || part === ".." || part === "."))) {
+        throw new Error("无效的托管技能路径。");
+    }
+    const canonical = path.join(configDir, "skills", name);
+    const targets = new Set();
+    for (const provider of providers) {
+        const directory = provider === "claude" ? ".claude" : provider === "qoder" ? ".qoder" : ".agents";
+        targets.add(path.join(home, directory, "skills", name));
+    }
+    // Preflight every target before touching anything; existing user content is never replaced.
+    for (const target of targets) {
+        try {
+            const info = await lstat(target);
+            if (!info.isSymbolicLink() || path.resolve(path.dirname(target), await readlink(target)) !== path.resolve(canonical)) {
+                throw new Error(`已有同名技能，保留原内容，请先手动处理：${target}`);
+            }
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+    }
+    const directories = new Set([canonical]);
+    for (const file of Object.keys(files)) {
+        let directory = path.dirname(path.join(canonical, file));
+        while (directory !== canonical) {
+            directories.add(directory);
+            directory = path.dirname(directory);
+        }
+    }
+    for (const directory of directories) {
+        try {
+            if (!(await lstat(directory)).isDirectory())
+                throw new Error(`技能目录不是普通目录，保留原内容：${directory}`);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+    }
+    for (const file of [...Object.keys(files), ".wand-managed.json"]) {
+        try {
+            if (!(await lstat(path.join(canonical, file))).isFile())
+                throw new Error(`技能文件不是普通文件，保留原内容：${file}`);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+    }
+    let previous = {};
+    try {
+        previous = JSON.parse(await readFile(path.join(canonical, ".wand-managed.json"), "utf8"));
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    const contents = Object.entries(files).map(([file, content]) => ({ file, content }));
+    for (const { file, content } of contents) {
+        try {
+            const old = await readFile(path.join(canonical, file), "utf8");
+            if (old !== content && sha(old) !== previous[file])
+                throw new Error(`技能已有用户修改，拒绝覆盖：${file}`);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+    }
+    for (const { file, content } of contents) {
+        await mkdir(path.dirname(path.join(canonical, file)), { recursive: true });
+        await writeFile(path.join(canonical, file), content, { mode: 0o644 });
+    }
+    await writeFile(path.join(canonical, ".wand-managed.json"), JSON.stringify(Object.fromEntries(contents.map(({ file, content }) => [file, sha(content)]))), { mode: 0o600 });
+    for (const target of targets) {
+        await mkdir(path.dirname(target), { recursive: true });
+        try {
+            await symlink(canonical, target, "dir");
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+        }
+        if (await realpath(target) !== await realpath(canonical))
+            throw new Error("技能链接目标校验失败。");
+    }
+    return { installed: [...targets], providers };
+}

package/dist/model-auto-assign.js

@@ -117,7 +117,7 @@ async function decideWithAi(request, candidates) {
     const message = `任务提示词：\n${task}\n\n可选模型分组：\n${list}\n\n只输出上面列出的分组名之一；都不合适就输出 -。`;
     const text = call
         ? await call({ system, prompt: message }, ai)
-        : await callConfiguredAiText({ system, prompt: message }, request.cwd ?? process.cwd(), request.language ?? "", { ...ai, budgetMs: AUTO_ASSIGN_AI_BUDGET_MS }, (raw) => String(raw).trim());
+        : await callConfiguredAiText({ system, prompt: message }, request.cwd ?? process.cwd(), request.language ?? "", { ...ai, purpose: "model-auto-assign", budgetMs: AUTO_ASSIGN_AI_BUDGET_MS }, (raw) => String(raw).trim());
     const flat = collapseWhitespace(text);
     if (!flat || flat === "-" || flat === "无")
         return { group: null, calls: 1 };

package/dist/process-manager.js

@@ -718,7 +718,7 @@ export class ProcessManager extends EventEmitter {
                     ai: resolveSystemAiContext({
                         provider: groupProvider, runner: undefined, command: providerCliCommand(groupProvider),
                         structuredState: undefined, selectedModel: null, thinkingEffort: opts?.thinkingEffort,
-                    }, this.config, this.storage.getSystemSiliconEmployee(), this.free),
+                    }, this.config, this.storage.getSystemSiliconEmployee(), this.free, { storage: this.storage }),
                     cwd: resolveSessionCwd(cwd, this.config.defaultCwd),
                     language: this.config.language,
                 });

package/dist/prompt-optimizer.js

@@ -32,7 +32,7 @@ export async function optimizePrompt(rawText, language, cwd, ai = {}) {
     }
     const request = buildOptimizePrompt(text, language);
     try {
-        return await callConfiguredAiText(request, cwd ?? process.cwd(), language, ai, (raw) => {
+        return await callConfiguredAiText(request, cwd ?? process.cwd(), language, { ...ai, purpose: "prompt-optimize" }, (raw) => {
             const cleaned = raw
                 .replace(/^```[a-zA-Z]*\n?/, "")
                 .replace(/\n?```$/, "")

package/dist/scheduled-task-activity.d.ts

@@ -0,0 +1,16 @@
+import type { ScheduledTaskRunView, ScheduledTaskRunFactView } from "./scheduled-task-types.js";
+export type DayOutcome = ScheduledTaskRunView["executionStatus"] | "mixed" | "empty";
+export interface ExecutionDay<T extends ScheduledTaskRunFactView = ScheduledTaskRunView> {
+    key: string;
+    records: T[];
+    outcome: DayOutcome;
+    counts: Partial<Record<ScheduledTaskRunView["executionStatus"], number>>;
+    available: boolean;
+    level: number;
+}
+/** A date-only key in the explicit display zone, never the browser's implicit zone. */
+export declare function dateKey(value: string | Date, timeZone: string): string;
+export declare function addDateDays(key: string, days: number): string;
+export declare function latestExecution<T extends ScheduledTaskRunFactView>(records: readonly T[]): T | undefined;
+/** Executions belong to the actual claim date. A late catch-up is not painted into its old scheduled day. */
+export declare function executionDays<T extends ScheduledTaskRunFactView>(records: readonly T[], now: Date, createdAt: string, timeZone: string, weeks?: number): ExecutionDay<T>[];

package/dist/scheduled-task-activity.js

@@ -0,0 +1,42 @@
+/** A date-only key in the explicit display zone, never the browser's implicit zone. */
+export function dateKey(value, timeZone) {
+    const date = typeof value === "string" ? new Date(value) : value;
+    const parts = new Intl.DateTimeFormat("en-CA", { timeZone, year: "numeric", month: "2-digit", day: "2-digit" }).formatToParts(date);
+    return ["year", "month", "day"].map(type => parts.find(part => part.type === type).value).join("-");
+}
+export function addDateDays(key, days) {
+    const date = new Date(`${key}T12:00:00Z`);
+    date.setUTCDate(date.getUTCDate() + days);
+    return date.toISOString().slice(0, 10);
+}
+export function latestExecution(records) {
+    return [...records].filter(record => Number.isFinite(Date.parse(record.claimedAt))).sort((a, b) => Date.parse(b.claimedAt) - Date.parse(a.claimedAt))[0];
+}
+/** Executions belong to the actual claim date. A late catch-up is not painted into its old scheduled day. */
+export function executionDays(records, now, createdAt, timeZone, weeks = 12) {
+    weeks = Number.isFinite(weeks) ? Math.max(1, Math.min(53, Math.trunc(weeks))) : 12;
+    const today = dateKey(now, timeZone);
+    const weekday = (new Date(`${today}T12:00:00Z`).getUTCDay() + 6) % 7;
+    const start = addDateDays(today, -weekday - (weeks - 1) * 7);
+    const created = dateKey(createdAt, timeZone);
+    const buckets = new Map();
+    for (const record of records) {
+        if (!Number.isFinite(Date.parse(record.claimedAt)))
+            continue;
+        const key = dateKey(record.claimedAt, timeZone);
+        const bucket = buckets.get(key) ?? [];
+        bucket.push(record);
+        buckets.set(key, bucket);
+    }
+    return Array.from({ length: weeks * 7 }, (_, index) => {
+        const key = addDateDays(start, index);
+        const daily = [...(buckets.get(key) ?? [])].sort((a, b) => Date.parse(b.claimedAt) - Date.parse(a.claimedAt));
+        const available = key >= created && key <= today || daily.length > 0;
+        const counts = {};
+        for (const record of daily)
+            counts[record.executionStatus] = (counts[record.executionStatus] ?? 0) + 1;
+        const states = Object.keys(counts);
+        const outcome = states.length > 1 ? "mixed" : states[0] ?? "empty";
+        return { key, records: daily, counts, outcome, available, level: Math.min(3, daily.length) };
+    });
+}