@co0ontty/wand 4.89.5 → 4.90.0

package/dist/system-employee.d.ts

@@ -6,7 +6,7 @@ export { SYSTEM_EMPLOYEE_ID, SYSTEM_EMPLOYEE_KEY, SYSTEM_EMPLOYEE_NAME, SYSTEM_E
  * 内置的「系统运维」员工。
  *
  * Wand 自己的 AI 调用（commit message / tag、提示词优化、会话与任务标题、
- * 员工起草）都通过这位员工的候选链执行：身份和头像固定，不可归档、不可删除；
+ * 等）通过这位员工的候选链执行；员工招聘由独立 HR 负责。该员工：身份和头像固定，不可归档、不可删除；
  * 名字、职责、人设与执行候选（工具 + 引擎 + 模型 + 思考深度）由用户维护。
  */
 export declare const SYSTEM_EMPLOYEE_DUTY = "Wand \u7CFB\u7EDF\u8FD0\u7EF4\uFF1A\u670D\u52A1\u4E0E CLI \u7EBF\u8DEF\u3001\u66F4\u65B0\u5206\u53D1\u3001\u4ED3\u5E93\u4E0E\u4F1A\u8BDD\u64CD\u4F5C\uFF0CWand \u81EA\u6709 AI \u4EFB\u52A1\u7684\u6267\u884C\u8005\u3002";

package/dist/system-employee.js

@@ -8,7 +8,7 @@ export { SYSTEM_EMPLOYEE_ID, SYSTEM_EMPLOYEE_KEY, SYSTEM_EMPLOYEE_NAME, SYSTEM_E
  * 内置的「系统运维」员工。
  *
  * Wand 自己的 AI 调用（commit message / tag、提示词优化、会话与任务标题、
- * 员工起草）都通过这位员工的候选链执行：身份和头像固定，不可归档、不可删除；
+ * 等）通过这位员工的候选链执行；员工招聘由独立 HR 负责。该员工：身份和头像固定，不可归档、不可删除；
  * 名字、职责、人设与执行候选（工具 + 引擎 + 模型 + 思考深度）由用户维护。
  */
 export const SYSTEM_EMPLOYEE_DUTY = "Wand 系统运维：服务与 CLI 线路、更新分发、仓库与会话操作，Wand 自有 AI 任务的执行者。";

package/dist/task-archive-policy.js

@@ -6,7 +6,7 @@ export function canArchiveTask(storage, sessions, taskId) {
     if (!task || task.status === "doing")
         return false;
     if (storage.listWandTaskSessionIds(task.id).some(id => {
-        const session = sessions?.getLatest(id) ?? storage.getSession(id);
+        const session = sessions?.getSlim(id) ?? storage.getSessionSlim(id);
         return session ? isArchiveBlocked(session) : false;
     }))
         return false;

package/dist/task-read-model.d.ts

@@ -0,0 +1,27 @@
+import type { SessionRegistry } from "./session-registry.js";
+import type { WandStorage } from "./storage.js";
+import type { WandTask } from "./task-types.js";
+import type { SessionSnapshot } from "./types.js";
+/** Request-scoped projection, never an authority for mutations or a cross-request cache. */
+export declare class TaskReadModel {
+    readonly storage: WandStorage;
+    readonly sessions: SessionSnapshot[];
+    readonly sessionsById: Map<string, SessionSnapshot>;
+    readonly sessionsByTask: Map<string, SessionSnapshot[]>;
+    readonly tasks: WandTask[];
+    readonly cardsByContainer: Map<string, WandTask>;
+    readonly workspaces: Map<string, import("./types.js").Workspace>;
+    readonly milestones: import("./task-types.js").WandTaskMilestone[];
+    readonly activeTeamTasks: Set<string>;
+    constructor(storage: WandStorage, registry?: SessionRegistry, snapshots?: SessionSnapshot[]);
+    taskSessions(task: WandTask): SessionSnapshot[];
+    canArchive(task: WandTask): boolean;
+    milestone(id: string | null | undefined): {
+        milestoneId: string | null;
+        milestone: {
+            id: string;
+            name: string;
+            isDefault: boolean;
+        } | null;
+    };
+}

package/dist/task-read-model.js

@@ -0,0 +1,47 @@
+import { isArchiveBlocked } from "./archive-policy.js";
+import { AI_TEAM_ACTIVE_RUN_STATUSES } from "./ai-team-types.js";
+/** Request-scoped projection, never an authority for mutations or a cross-request cache. */
+export class TaskReadModel {
+    storage;
+    sessions;
+    sessionsById;
+    sessionsByTask = new Map();
+    tasks;
+    cardsByContainer;
+    workspaces;
+    milestones;
+    activeTeamTasks;
+    constructor(storage, registry, snapshots) {
+        this.storage = storage;
+        this.sessions = snapshots ?? registry?.listSlim() ?? storage.loadSessionsSlim();
+        this.sessionsById = new Map(this.sessions.map(session => [session.id, session]));
+        for (const session of this.sessions) {
+            if (!session.workspaceTaskId)
+                continue;
+            const bucket = this.sessionsByTask.get(session.workspaceTaskId) ?? [];
+            bucket.push(session);
+            this.sessionsByTask.set(session.workspaceTaskId, bucket);
+        }
+        this.tasks = storage.listWandTasks();
+        this.cardsByContainer = new Map(this.tasks.filter(task => task.workspaceTaskId).map(task => [task.workspaceTaskId, task]));
+        this.workspaces = new Map(storage.listWorkspaces().map(workspace => [workspace.id, workspace]));
+        this.milestones = storage.listWandMilestones();
+        this.activeTeamTasks = new Set(storage.listAiTeamRuns({ statuses: AI_TEAM_ACTIVE_RUN_STATUSES }).map(run => run.taskId));
+    }
+    taskSessions(task) {
+        if (task.workspaceTaskId)
+            return this.sessionsByTask.get(task.workspaceTaskId) ?? [];
+        // Archived legacy cards retain their old links; active membership uses the canonical column.
+        return task.status === "archived" ? this.storage.listWandTaskSessionIds(task.id)
+            .flatMap(id => this.sessionsById.get(id) ? [this.sessionsById.get(id)] : []) : [];
+    }
+    canArchive(task) {
+        return task.status !== "doing" && !this.taskSessions(task).some(isArchiveBlocked)
+            && !this.activeTeamTasks.has(task.id) && !(task.workspaceTaskId && this.activeTeamTasks.has(task.workspaceTaskId));
+    }
+    milestone(id) {
+        const milestone = id ? this.milestones.find(value => value.id === id) : this.milestones.find(value => value.isDefault);
+        return { milestoneId: milestone?.id ?? null,
+            milestone: milestone ? { id: milestone.id, name: milestone.name, isDefault: milestone.isDefault } : null };
+    }
+}

package/dist/task-retention.d.ts

@@ -1,4 +1,4 @@
-/** 看板任务的自动归档 / 自动删除。会话保留期不走这里。 */
+/** 任务、会话与已结束团队运行的统一自动归档 / 自动删除策略。 */
 export declare const TASK_RETENTION_MIN_DAYS = 1;
 export declare const TASK_RETENTION_MAX_DAYS = 365;
 export declare const DEFAULT_TASK_AUTO_ARCHIVE_DAYS = 7;

package/dist/task-retention.js

@@ -1,4 +1,4 @@
-/** 看板任务的自动归档 / 自动删除。会话保留期不走这里。 */
+/** 任务、会话与已结束团队运行的统一自动归档 / 自动删除策略。 */
 export const TASK_RETENTION_MIN_DAYS = 1;
 export const TASK_RETENTION_MAX_DAYS = 365;
 export const DEFAULT_TASK_AUTO_ARCHIVE_DAYS = 7;

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

@@ -0,0 +1,30 @@
+import type { WandStorage } from "./storage.js";
+import type { WandConfig, ProcessEvent } from "./types.js";
+import type { OpenRouterFreeModelsService } from "./openrouter-free-models.js";
+import { generateWandTaskTitle } from "./task-title.js";
+export interface AutoTaskTitleOptions {
+    config?: WandConfig;
+    free?: Pick<OpenRouterFreeModelsService, "resolveForCall">;
+    generateTitle?: typeof generateWandTaskTitle;
+    cwd?: string;
+}
+/** One owner per storage lifetime; mutation notifications, never GET, drive naming. */
+export declare class TaskTitleService {
+    private storage;
+    private options;
+    private pending;
+    private flight;
+    private controller;
+    private disposed;
+    private unsubscribe;
+    constructor(storage: WandStorage, options?: AutoTaskTitleOptions);
+    ingest(event: ProcessEvent): void;
+    configure(options: AutoTaskTitleOptions): void;
+    refresh(options?: AutoTaskTitleOptions): void;
+    private drain;
+    dispose(): void;
+}
+export declare function taskTitleService(storage: WandStorage, options?: AutoTaskTitleOptions): TaskTitleService;
+export declare function refreshAutoBoardTaskTitles(storage: WandStorage, options?: AutoTaskTitleOptions): void;
+/** Compatibility/test wait, not a shared execution queue. */
+export declare function whenWandTaskTitlesSettled(): Promise<void>;

package/dist/task-title-service.js

@@ -0,0 +1,122 @@
+import { generateWandTaskTitle, provisionalTaskTitleFromDescription, TASK_TITLE_MAX_LENGTH } from "./task-title.js";
+import { isAutoNameableBoardTask, taskAutoNameSignature, taskAutoNameSourceText } from "./wand-task-sync.js";
+import { resolveSystemAiContext } from "./session-ai-context.js";
+import { getErrorMessage } from "./error-utils.js";
+const services = new WeakMap();
+const flights = new Set();
+/** One owner per storage lifetime; mutation notifications, never GET, drive naming. */
+export class TaskTitleService {
+    storage;
+    options;
+    pending = new Map();
+    flight = null;
+    controller = new AbortController();
+    disposed = false;
+    unsubscribe;
+    constructor(storage, options = {}) {
+        this.storage = storage;
+        this.options = options;
+        this.unsubscribe = storage.onTaskTitleChange(() => this.refresh());
+        storage.onClose(() => this.dispose());
+    }
+    ingest(event) {
+        const data = event.data;
+        if (event.type === "started" || event.type === "ended" || (data && ("title" in data || "description" in data))) {
+            this.storage.notifyTaskTitleChange();
+        }
+    }
+    configure(options) {
+        this.options = { ...this.options, ...options };
+    }
+    refresh(options = {}) {
+        if (this.disposed)
+            return;
+        this.configure(options);
+        for (const card of this.storage.listWandTasks()) {
+            if (!isAutoNameableBoardTask(card))
+                continue;
+            const source = taskAutoNameSourceText(this.storage, card);
+            if (!source)
+                continue;
+            const signature = taskAutoNameSignature(source);
+            if (card.autoTitleSignature === signature)
+                continue;
+            const title = provisionalTaskTitleFromDescription(source);
+            this.storage.updateWandTask(card.id, { titleSource: "auto", autoTitleSignature: signature,
+                ...(title && title !== card.title ? { title } : {}) });
+            if (this.options.generateTitle || this.options.config)
+                this.pending.set(card.id, { source, signature });
+        }
+        if (this.flight || !this.pending.size)
+            return;
+        const flight = Promise.resolve().then(() => this.drain());
+        this.flight = flight;
+        flights.add(flight);
+        void flight.finally(() => { flights.delete(flight); if (this.flight === flight)
+            this.flight = null; }).catch(() => { });
+    }
+    async drain() {
+        while (!this.disposed && this.pending.size) {
+            const [id, input] = this.pending.entries().next().value;
+            this.pending.delete(id);
+            try {
+                const current = this.storage.getWandTask(id);
+                if (!current || current.titleSource !== "auto" || current.autoTitleSignature !== input.signature
+                    || !taskAutoNameSourceText(this.storage, current))
+                    continue;
+                const { config, free, generateTitle = generateWandTaskTitle } = this.options;
+                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) : {};
+                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 });
+                if (this.disposed)
+                    return;
+                const latest = this.storage.getWandTask(id);
+                if (!latest || latest.titleSource !== "auto" || latest.autoTitleSignature !== input.signature
+                    || !taskAutoNameSourceText(this.storage, latest))
+                    continue;
+                const clipped = title.slice(0, TASK_TITLE_MAX_LENGTH);
+                if (clipped && clipped !== latest.title)
+                    this.storage.updateWandTask(id, { title: clipped });
+            }
+            catch (error) {
+                if (!this.disposed)
+                    console.error(`[WandTask] Failed to auto-generate title for ${id}:`, getErrorMessage(error));
+            }
+        }
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.pending.clear();
+        this.unsubscribe();
+        this.controller.abort();
+        if (this.flight)
+            flights.delete(this.flight);
+    }
+}
+export function taskTitleService(storage, options = {}) {
+    let service = services.get(storage);
+    if (!service) {
+        service = new TaskTitleService(storage, options);
+        services.set(storage, service);
+    }
+    else
+        service.configure(options);
+    return service;
+}
+export function refreshAutoBoardTaskTitles(storage, options = {}) {
+    taskTitleService(storage, options).refresh(options);
+}
+/** Compatibility/test wait, not a shared execution queue. */
+export async function whenWandTaskTitlesSettled() {
+    await Promise.resolve();
+    while (flights.size) {
+        await Promise.all([...flights]);
+        await Promise.resolve();
+    }
+}

package/dist/task-title.d.ts

@@ -1,4 +1,4 @@
-import { type QuickCommitAiOptions } from "./git-quick-commit.js";
+import { type QuickCommitAiOptions } from "./ai-text-runner.js";
 /** 任务标题留空时由描述自动生成；面板上显示得下，也不至于截断成半句话。 */
 export declare const TASK_TITLE_MAX_LENGTH = 40;
 /**

package/dist/task-title.js

@@ -1,4 +1,4 @@
-import { callConfiguredAiText } from "./git-quick-commit.js";
+import { callConfiguredAiText } from "./ai-text-runner.js";
 import { clipAtWordBoundary } from "./text-utils.js";
 /** 任务标题留空时由描述自动生成；面板上显示得下，也不至于截断成半句话。 */
 export const TASK_TITLE_MAX_LENGTH = 40;

package/dist/terminal-daemon-client.js

@@ -1,5 +1,6 @@
 import { existsSync, readFileSync } from "node:fs";
 import net from "node:net";
+import { probeUnixSocket as probeSocket } from "./socket-probe.js";
 import { spawn } from "node:child_process";
 import process from "node:process";
 import { StringDecoder } from "node:string_decoder";
@@ -811,24 +812,6 @@ export async function connectExistingTerminalHost(configPath) {
     const paths = terminalDaemonPaths(configPath);
     return tryConnect(paths.socketPath, paths.tokenPath);
 }
-function probeSocket(socketPath) {
-    return new Promise((resolve) => {
-        const socket = net.createConnection(socketPath);
-        let settled = false;
-        const finish = (alive) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            socket.destroy();
-            resolve(alive);
-        };
-        socket.once("connect", () => finish(true));
-        socket.once("error", () => finish(false));
-        const timer = setTimeout(() => finish(false), 300);
-        timer.unref?.();
-    });
-}
 function startDetachedDaemon(configPath) {
     const entry = process.argv[1];
     if (!entry || !existsSync(entry))

package/dist/user-memory.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import { DEFAULT_EMPLOYEE_ID } from "./ai-team-types.js";
 import { explicitEmployeeMemoryContent } from "./employee-knowledge-content.js";
-import { callConfiguredAiText } from "./git-quick-commit.js";
+import { callConfiguredAiText } from "./ai-text-runner.js";
 import { resolveSystemAiContext } from "./session-ai-context.js";
 import { USER_MEMORY_CATEGORIES, USER_MEMORY_REFRESH_MS, USER_MEMORY_RETENTION_MS, USER_MEMORY_TEXT_MAX_CHARS, } from "./user-memory-types.js";
 /** Defense in depth, not a promise that arbitrary secrets can always be recognized. */

package/dist/web-ui/asset-runtime.d.ts

@@ -0,0 +1,12 @@
+declare global {
+    var __wandBrowserRuntime: {
+        configPath: string;
+        aiTeamsChunkSrc: string;
+        plushAvatarChunkSrc: string;
+    } | undefined;
+}
+export declare const browserAssetRuntime: {
+    configPath: string;
+    aiTeamsChunkSrc: string;
+    plushAvatarChunkSrc: string;
+};

package/dist/web-ui/asset-runtime.js

@@ -0,0 +1,6 @@
+// Literal fallbacks keep standalone component harnesses and legacy builds usable.
+export const browserAssetRuntime = globalThis.__wandBrowserRuntime ?? {
+    configPath: "${wandConfigPath}",
+    aiTeamsChunkSrc: "${aiTeamsChunkSrc}",
+    plushAvatarChunkSrc: "${plushAvatarChunkSrc}",
+};

package/dist/web-ui/composer-avatar-activity.d.ts

@@ -0,0 +1,6 @@
+import type { ConversationTurn } from "../types.js";
+import { type RunningActivityShape } from "./running-activity.js";
+export type AvatarFileActivity = "idle" | "reading" | "writing";
+/** Project only unfinished file tools in the current turn. Results retire their
+ * own invocation, including errors; a concurrent older tool can remain active. */
+export declare function composerAvatarActivity(activity: RunningActivityShape | undefined, messages?: readonly ConversationTurn[]): AvatarFileActivity;

package/dist/web-ui/composer-avatar-activity.js

@@ -0,0 +1,29 @@
+import { computeRunningPhase } from "./running-activity.js";
+/** Project only unfinished file tools in the current turn. Results retire their
+ * own invocation, including errors; a concurrent older tool can remain active. */
+export function composerAvatarActivity(activity, messages = []) {
+    if (computeRunningPhase(activity) !== "executing")
+        return "idle";
+    let start = messages.length - 1;
+    while (start >= 0 && messages[start].role !== "user")
+        start--;
+    const calls = new Map();
+    const completed = new Set();
+    for (let index = start + 1; index < messages.length; index++) {
+        const message = messages[index];
+        for (const block of message.content ?? []) {
+            if (block.__subagent)
+                continue;
+            if (block.type === "tool_result")
+                completed.add(block.tool_use_id);
+            if (block.type !== "tool_use" || message.completedAt)
+                continue;
+            const kind = block.activity?.kind;
+            if (kind === "read_file" || kind === "edit_file") {
+                // Duplicate snapshots update the same invocation without reordering it.
+                calls.set(block.id, kind === "read_file" ? "reading" : "writing");
+            }
+        }
+    }
+    return [...calls].reverse().find(([id]) => !completed.has(id))?.[1] ?? "idle";
+}