@co0ontty/wand 4.94.0 → 4.95.0

package/README.md

@@ -73,7 +73,10 @@ and `beta`, including a stable release that supersedes its prerelease. Installin
 keeps the Beta subscription enabled. Updates pin the checked version, wait for Core turns,
 and restart only the Web service. If an old updater cannot run, rerun `install.sh` for a
 staged recovery that preserves the previous installation and service scope. Node.js must
-meet the new package's requirement. See [Web update and recovery](docs/web-updates.md).
+meet the new package's requirement. The runtime minimum is **Node.js 22.19.0**;
+maintained even-numbered LTS releases are recommended (22.x / 24.x, with 26.x
+also checked for compatibility). `.nvmrc` pins reproducible builds, not the
+installation minimum. See [Web update and recovery](docs/web-updates.md).
 
 ### Configuration
 

package/dist/ai-text-runner.d.ts

@@ -1,4 +1,5 @@
 import { type EmployeeTextDeps } from "./employee-text.js";
+import { type AiCallTraceFactory, type SystemAiPurpose } from "./system-ai-call.js";
 import type { AiTextRequest, SessionProvider, SessionSnapshot } from "./types.js";
 export { QuickCommitError } from "./command-error.js";
 /** Neutral one-shot text execution. Tool-running Git fallback never uses the retry chain. */
@@ -20,6 +21,9 @@ export interface QuickCommitAiOptions {
     /** 整条候选链的时间上限；默认 CLI_CHAIN_BUDGET_MS。第一条消息里的调用要短得多。 */
     budgetMs?: number;
     signal?: AbortSignal;
+    purpose?: SystemAiPurpose;
+    traceFactory?: AiCallTraceFactory;
+    onCallSessionCreated?(sessionId: string): void;
 }
 type CliAiTextOptions = QuickCommitAiOptions & {
     deadline?: number;

package/dist/ai-text-runner.js

@@ -10,6 +10,7 @@ import { getGitErrorMessage } from "./git-utils.js";
 import { buildLanguageDirective } from "./language-prompt.js";
 import { candidateInstalled, isSessionProvider } from "./session-provider.js";
 import { asRecord } from "./structured-content.js";
+import { AiCallTraceError } from "./system-ai-call.js";
 import { composeSystemFallback, systemPromptFlag, thinkingEffortToClaudeCliEffort, thinkingEffortToCodexReasoningEffort, thinkingEffortToGrokEffort, thinkingEffortToOpenCodeVariant, thinkingEffortToPiLevel, thinkingEffortToQoderEffort } from "./structured-provider-common.js";
 export { QuickCommitError } from "./command-error.js";
 const CLAUDE_MESSAGE_TIMEOUT_MS = 60_000;
@@ -521,7 +522,7 @@ function singleCandidate(opts) {
  * 只有一条候选时保持原行为（错误原样抛出，不摘要）。
  * 仅用于一次性文本生成；执行工具的任务不能使用这条无条件重试路径。
  */
-async function callTextCandidates(request, cwd, language, opts, parseOutput) {
+async function callTextCandidates(request, cwd, language, opts, parseOutput, trace) {
     opts.signal?.throwIfAborted();
     const { resolveModelGroupModels } = await import("./model-groups.js");
     const modelGroups = opts.modelGroups ?? opts.employeeText?.config.modelGroups;
@@ -549,6 +550,8 @@ async function callTextCandidates(request, cwd, language, opts, parseOutput) {
         try {
             const generate = await abortableEmployeeText(prepareEmployeeTextCandidate({
                 ...opts.employeeText,
+                callSessionId: trace?.sessionId,
+                onUsage: usage => { opts.employeeText?.onUsage?.(usage); trace?.usageReported(usage); },
                 config: { ...opts.employeeText?.config, defaultCwd: cwd, inheritEnv: opts.inheritEnv ?? opts.employeeText?.config.inheritEnv, modelGroups },
             }, { ...candidate, model: candidate.model ?? "default", thinkingEffort: candidate.thinkingEffort ?? opts.thinkingEffort ?? "off", mode: "default", kind: "structured" }, request, signal), signal);
             signal.throwIfAborted();
@@ -558,9 +561,28 @@ async function callTextCandidates(request, cwd, language, opts, parseOutput) {
             clearTimeout(timer);
         }
     };
-    if (chain.length === 1)
-        return parseOutput(await call(chain[0]));
+    if (chain.length === 1) {
+        const candidate = chain[0];
+        trace?.candidateStarted({ ...candidate, thinkingEffort: candidate.thinkingEffort ?? opts.thinkingEffort ?? undefined });
+        let phase = "execution";
+        try {
+            const raw = await call(candidate);
+            phase = "result";
+            const parsed = await parseOutput(raw);
+            trace?.candidateSucceeded(raw, parsed);
+            return parsed;
+        }
+        catch (error) {
+            trace?.candidateFailed(candidate, error, phase);
+            throw error;
+        }
+    }
     const installed = chain.filter((candidate) => candidateInstalled(candidate));
+    if (installed.length)
+        for (const candidate of chain) {
+            if (!installed.includes(candidate))
+                trace?.candidateSkipped(candidate, "CLI 未安装，未提交输入。");
+        }
     const attempts = installed.length ? installed : chain;
     const errors = [];
     for (const candidate of attempts) {
@@ -569,15 +591,22 @@ async function callTextCandidates(request, cwd, language, opts, parseOutput) {
             errors.push("已超过等待上限");
             break;
         }
+        trace?.candidateStarted({ ...candidate, thinkingEffort: candidate.thinkingEffort ?? opts.thinkingEffort ?? undefined });
+        let phase = "execution";
         try {
             const text = await call(candidate);
+            phase = "result";
             const result = await parseOutput(text);
+            trace?.candidateSucceeded(text, result);
             if (candidate !== attempts[0]) {
                 console.info(`[SystemAi] 候选 ${chain.indexOf(candidate) + 1}/${chain.length} (${candidate.provider}) 成功`);
             }
             return result;
         }
         catch (error) {
+            if (error instanceof AiCallTraceError)
+                throw error;
+            trace?.candidateFailed(candidate, error, phase);
             opts.signal?.throwIfAborted();
             errors.push(`${candidate.provider}: ${getGitErrorMessage(error)}`);
             // 不记录提示词、路径、CLI 原始响应或可能带鉴权信息的错误正文。
@@ -588,5 +617,16 @@ async function callTextCandidates(request, cwd, language, opts, parseOutput) {
     throw new QuickCommitError(`所有执行候选均失败：${errors.join("；")}`, "AI_FALLBACK_FAILED");
 }
 export async function callConfiguredAiText(request, cwd, language, opts, parseOutput = (raw) => raw) {
-    return callTextCandidates(withOpsPersona(request, opts.opsPersona), cwd, language, opts, parseOutput);
+    const trace = opts.traceFactory?.start(opts.purpose ?? "system-text", request, cwd);
+    try {
+        if (trace)
+            opts.onCallSessionCreated?.(trace.sessionId);
+        const result = await callTextCandidates(withOpsPersona(request, opts.opsPersona), cwd, language, opts, parseOutput, trace);
+        trace?.complete();
+        return result;
+    }
+    catch (error) {
+        trace?.fail(error, opts.signal?.aborted === true);
+        throw error;
+    }
 }

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
-  "commit": "4323ba1516bf4465bd3e239e67508a972f01a3e4",
-  "builtAt": "2026-10-15T00:50:47.298Z",
-  "version": "4.94.0",
+  "commit": "befb8fac24ba328a50e08d27ef6bf0e87c29515d",
+  "builtAt": "2026-10-15T20:12:59.388Z",
+  "version": "4.95.0",
   "channel": "stable"
 }

package/dist/cli-api.d.ts

@@ -5,6 +5,7 @@ export declare class WandCliApi {
     constructor(config: WandConfig);
     get<T>(pathname: string): Promise<T>;
     post<T>(pathname: string, body: unknown): Promise<T>;
+    patch<T>(pathname: string, body: unknown): Promise<T>;
     del<T>(pathname: string): Promise<T>;
     private login;
     private request;

package/dist/cli-api.js

@@ -12,6 +12,9 @@ export class WandCliApi {
     async post(pathname, body) {
         return this.request("POST", pathname, body);
     }
+    async patch(pathname, body) {
+        return this.request("PATCH", pathname, body);
+    }
     async del(pathname) {
         return this.request("DELETE", pathname);
     }
@@ -31,12 +34,14 @@ export class WandCliApi {
         try {
             parsed = result.body ? JSON.parse(result.body) : {};
         }
-        catch { /* handled below */ }
+        catch {
+            throw new Error(`Wand 响应不是有效 JSON (HTTP ${result.status})；${method === "GET" ? "无法确认结果。" : "请求可能已接受，请回读核对，不要重复提交。"}`);
+        }
         const error = parsed && typeof parsed === "object" && "error" in parsed && typeof parsed.error === "string"
             ? parsed.error
             : null;
         if (result.status < 200 || result.status >= 300 || error) {
-            throw new Error(error || `Wand 请求失败 (HTTP ${result.status})`);
+            throw new Error(`Wand 请求失败 (HTTP ${result.status})${error ? `：${error}` : ""}`);
         }
         return parsed;
     }

package/dist/cli.js

@@ -197,6 +197,44 @@ async function main() {
             }
             break;
         }
+        case "employee:list":
+        case "workspace:list":
+        case "session:create":
+        case "session:resume":
+        case "schedule:list":
+        case "schedule:read":
+        case "schedule:create":
+        case "schedule:update": {
+            const { parseSystemCliCommand } = await import("./system-cli.js");
+            const operationArgs = args.slice(1);
+            for (const flag of ["-c", "--config"]) {
+                const index = operationArgs.indexOf(flag);
+                if (index !== -1) {
+                    if (!operationArgs[index + 1] || operationArgs[index + 1].startsWith("-"))
+                        throw new Error("配置路径缺失。");
+                    operationArgs.splice(index, 2);
+                }
+            }
+            const operation = await parseSystemCliCommand(command, operationArgs);
+            const { config } = await loadConfigForCli(configPath);
+            process.stdout.write(`${JSON.stringify(await operation(new WandCliApi(config)), null, 2)}\n`);
+            break;
+        }
+        case "system:skills": {
+            for (let index = 1; index < args.length; index += 2) {
+                if (!["--providers", "--config", "-c"].includes(args[index])
+                    || !args[index + 1] || args[index + 1].startsWith("-")) {
+                    throw new Error("用法：wand system:skills [--providers pi,claude,...] [-c <config-path>]");
+                }
+            }
+            const { installSystemSkill } = await import("./system-skill.js");
+            const { SESSION_PROVIDERS } = await import("./provider-catalog.js");
+            const selected = readFlagValue(args, "--providers")?.split(",") ?? [...SESSION_PROVIDERS];
+            if (selected.some(provider => !SESSION_PROVIDERS.includes(provider)))
+                throw new Error("未知CLI技能目标。");
+            process.stdout.write(`${JSON.stringify(await installSystemSkill(configPath, selected))}\n`);
+            break;
+        }
         case "session:list":
         case "session:read":
         case "session:send":
@@ -313,6 +351,15 @@ Commands:
   wand storage:cleanup [--apply]  Inspect/reclaim abandoned Wand runtime storage
 
 Agent runtime:
+  wand system:skills [--providers pi,claude,...]  Install the managed wand-system skill
+  wand employee:list [--include-archived]  List employee definitions (not private knowledge)
+  wand workspace:list       List project directories
+  wand session:create --stdin  Create an employee session from JSON
+  wand session:resume <id> --stdin  Continue the exact structured session with JSON input
+  wand schedule:list [--include-cancelled]
+  wand schedule:read <id>    Read schedule and execution history
+  wand schedule:create --stdin  Create a schedule from JSON (requestId required)
+  wand schedule:update <id> --stdin  Edit/pause/cancel (revision required)
   wand session:list         List sessions as JSON
   wand inbox:list           List mission inbox items as JSON
   wand session:read <id>    Read a complete session snapshot

package/dist/conversation-execution-preference.d.ts

@@ -0,0 +1,7 @@
+import type { SiliconEmployee } from "./ai-team-types.js";
+import { type WandTaskAgent } from "./task-types.js";
+/** Request-local only: never saved to the employee or used to mutate an existing run. */
+export type ConversationExecutionPreference = Pick<WandTaskAgent, "provider" | "engine" | "model" | "thinkingEffort">;
+export declare function parseConversationExecutionPreference(value: unknown): ConversationExecutionPreference | undefined;
+/** Manual selection is a single explicit candidate, not an implicit paid/fallback chain. */
+export declare function withConversationExecutionPreference(employee: SiliconEmployee, preference: ConversationExecutionPreference): SiliconEmployee;

package/dist/conversation-execution-preference.js

@@ -0,0 +1,26 @@
+import { isSessionProvider } from "./provider-catalog.js";
+import { isThinkingEffort } from "./structured-provider-common.js";
+import { normalizeWandTaskAgentMode } from "./task-types.js";
+export function parseConversationExecutionPreference(value) {
+    if (value === undefined)
+        return undefined;
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("临时执行配置无效。");
+    const body = value;
+    if (!isSessionProvider(body.provider) || (body.engine !== undefined && body.engine !== "cli" && body.engine !== "sdk")
+        || (body.engine === "sdk" && body.provider !== "pi"))
+        throw new Error("临时执行工具无效。");
+    if (typeof body.model !== "string" || !body.model.trim() || body.model.length > 128)
+        throw new Error("临时模型无效。");
+    if (!isThinkingEffort(body.thinkingEffort)
+        || (body.thinkingEffort.includes(":") && !body.thinkingEffort.startsWith(`${body.provider}:`)))
+        throw new Error("临时思考深度无效。");
+    return { provider: body.provider, engine: body.engine,
+        model: body.model.trim(), thinkingEffort: body.thinkingEffort };
+}
+/** Manual selection is a single explicit candidate, not an implicit paid/fallback chain. */
+export function withConversationExecutionPreference(employee, preference) {
+    const base = employee.agents.find(agent => agent.provider === preference.provider && (agent.engine ?? "cli") === (preference.engine ?? "cli"));
+    return { ...employee, agents: [{ ...preference, kind: "structured",
+                mode: normalizeWandTaskAgentMode(preference.provider, base?.mode) }] };
+}

package/dist/conversation-organize-contract.d.ts

@@ -0,0 +1,70 @@
+import type { TaskOrganizeMode, TaskOrganizeTarget } from "./task-organize-contract.js";
+export interface ConversationOrganizationScope {
+    target?: TaskOrganizeTarget;
+    taskIds?: readonly string[];
+    sessionIds?: readonly string[];
+    mode: TaskOrganizeMode;
+}
+export interface ConversationOrganizationPreview {
+    token: string;
+    sessionCount: number;
+    manualSessionCount: number;
+    skippedSessionCount: number;
+    existingTaskCount: number;
+    contentCharacters: number;
+    estimatedModelRequests: number;
+    unchanged: boolean;
+    activeJobId?: string;
+}
+export interface ConversationOrganizationResult {
+    ok: true;
+    foundSessions: number;
+    eligibleSessions: number;
+    skippedManualSessions: number;
+    skippedSessions: number;
+    analyzedSessions: number;
+    createdTasks: Array<{
+        taskId: string;
+        cardId: string;
+        title: string;
+        sessionCount: number;
+    }>;
+    reusedTasks: Array<{
+        taskId: string;
+        title: string;
+        sessionCount: number;
+    }>;
+    updatedTasks: Array<{
+        taskId: string;
+        previousTitle: string;
+        title: string;
+    }>;
+    movedSessions: Array<{
+        sessionId: string;
+        taskId: string;
+        taskName: string;
+    }>;
+    unassignedSessions: Array<{
+        sessionId: string;
+        reason: string;
+    }>;
+    refused: Array<{
+        id: string;
+        kind: "session" | "task";
+        reason: string;
+    }>;
+    unchanged?: boolean;
+    cancelled?: boolean;
+    error?: string;
+}
+export interface ConversationOrganizationJob {
+    id: string;
+    status: "running" | "completed" | "failed" | "cancelled" | "interrupted";
+    stage: string;
+    processedSessions: number;
+    totalSessions: number;
+    modelRequests: number;
+    result: ConversationOrganizationResult;
+    logSessionId?: string;
+    error?: string;
+}

package/dist/conversation-organize-contract.js

@@ -0,0 +1 @@
+export {};

package/dist/conversation-organize-service.d.ts

@@ -0,0 +1,46 @@
+import type { WandStorage } from "./storage.js";
+import type { SessionSnapshot } from "./types.js";
+import type { AutoTaskTitleOptions } from "./task-title-service.js";
+import { type ConversationGroupingJudge } from "./conversation-organize.js";
+import type { ConversationOrganizationScope, ConversationOrganizationPreview, ConversationOrganizationJob } from "./conversation-organize-contract.js";
+export interface ConversationOrganizationDependencies {
+    titleOptions?: AutoTaskTitleOptions;
+    judge?: ConversationGroupingJudge;
+    summarize?(text: string, index: number, total: number, signal: AbortSignal): Promise<string>;
+    listSessions?(): SessionSnapshot[];
+    getSession?(id: string): SessionSnapshot | null;
+    refreshSession?(id: string): void;
+}
+export declare class ConversationOrganizationService {
+    private readonly storage;
+    private readonly deps;
+    private readonly previews;
+    private readonly active;
+    private readonly executing;
+    private readonly scopeJobs;
+    private readonly jobs;
+    private readonly operationTraces;
+    private readonly roleVersions;
+    private tail;
+    private closed;
+    constructor(storage: WandStorage, deps: ConversationOrganizationDependencies);
+    private save;
+    private scopeKey;
+    private getSession;
+    private taskDirectory;
+    private inScope;
+    private scan;
+    private fingerprint;
+    prepare(scope: ConversationOrganizationScope): ConversationOrganizationPreview;
+    start(token: string, force?: boolean): ConversationOrganizationJob;
+    get(id: string): ConversationOrganizationJob | null;
+    cancel(id: string): ConversationOrganizationJob | null;
+    private ai;
+    private summarize;
+    private taskCandidates;
+    private roleVersion;
+    private countModelRequest;
+    private execute;
+    private apply;
+}
+export declare function conversationOrganizationService(storage: WandStorage, deps: ConversationOrganizationDependencies): ConversationOrganizationService;