@co0ontty/wand 4.58.0 → 4.59.0

package/README.md

@@ -95,6 +95,7 @@ Common options:
 | `https` | `false` | Enable HTTPS with an auto-generated self-signed certificate |
 | `password` | random | Login password |
 | `language` | `""` | Preferred Claude response language |
+| `publicOrigin` | unset | Public URL clients should use, e.g. `https://home.example.com:8443`. Required when TLS terminates in an L4 proxy |
 
 ### System Service
 
@@ -262,6 +263,7 @@ wand config:set port 9443
 | `https` | `false` | 启用 HTTPS（自签证书自动生成） |
 | `password` | (随机生成) | 登录密码 |
 | `language` | `""` | Claude 回复语言偏好 |
+| `publicOrigin` | 未设置 | 客户端应使用的公开访问地址，如 `https://home.example.com:8443`。TLS 在 L4 反代终止时必填 |
 
 ### 系统服务
 

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
-  "commit": "3ab96a356a555f419adb4ec4c5cba63dfd170a5c",
-  "builtAt": "2026-09-11T13:51:01.381Z",
-  "version": "4.58.0",
+  "commit": "18846ddec22bf00f6ee5245b09d7266ab42a1056",
+  "builtAt": "2026-09-12T02:12:46.324Z",
+  "version": "4.59.0",
   "channel": "stable"
 }

package/dist/cli.js

@@ -761,6 +761,27 @@ function setConfigValue(config, key, value) {
                 ...config,
                 https: value === "true"
             };
+        case "publicOrigin": {
+            if (!value)
+                throw new Error("publicOrigin must not be empty; use 'wand config:unset publicOrigin' to clear it");
+            let parsed;
+            try {
+                parsed = new URL(value);
+            }
+            catch {
+                throw new Error("publicOrigin must be an absolute URL, e.g. https://home.example.com:8443");
+            }
+            if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+                throw new Error("publicOrigin must use http:// or https://");
+            }
+            if (parsed.username || parsed.password || parsed.pathname !== "/" || parsed.search || parsed.hash) {
+                throw new Error("publicOrigin must be a bare origin without credentials, path, query, or fragment");
+            }
+            return {
+                ...config,
+                publicOrigin: parsed.origin
+            };
+        }
         default:
             throw new Error(`Unsupported config key: ${key}`);
     }

package/dist/config.js

@@ -683,6 +683,23 @@ function mergeWithDefaults(input) {
         ...input,
         // Ensure https is boolean
         https: typeof input.https === "boolean" ? input.https : defaults.https,
+        // 只接受不带路径/查询/凭据的 http(s) origin；写了非法值就当作没配。
+        publicOrigin: (() => {
+            const raw = typeof input.publicOrigin === "string" ? input.publicOrigin.trim() : "";
+            if (!raw)
+                return undefined;
+            try {
+                const parsed = new URL(raw);
+                if (parsed.protocol !== "http:" && parsed.protocol !== "https:")
+                    return undefined;
+                if (!parsed.hostname || parsed.username || parsed.password)
+                    return undefined;
+                return parsed.origin;
+            }
+            catch {
+                return undefined;
+            }
+        })(),
         tls: (() => {
             if (!input.tls || typeof input.tls !== "object")
                 return undefined;

package/dist/server-task-routes.d.ts

@@ -1,16 +1,24 @@
 import type { Express, RequestHandler } from "express";
 import { type WandStorage } from "./storage.js";
+import { generateWandTaskTitle } from "./task-title.js";
 import type { SessionRegistry } from "./session-registry.js";
 import type { StructuredSessionManager } from "./structured-session-manager.js";
 import type { WandTaskAgent } from "./task-types.js";
 import type { WandConfig } from "./types.js";
+/** 任务面板上次选用的 CLI 工具 / 模型 / 思考深度；从未保存过时回落到 Claude 默认。 */
+export declare function readTaskBoardLastAgent(storage: WandStorage): WandTaskAgent;
+export declare function writeTaskBoardLastAgent(storage: WandStorage, agent: WandTaskAgent): void;
 export interface TaskRouteDependencies {
     storage: WandStorage;
     sessions?: SessionRegistry;
     structured?: StructuredSessionManager;
     config?: WandConfig;
     requireAdmin?: RequestHandler;
+    /** 可注入的任务标题生成器；测试里换成同步桩，避免真的起 CLI。 */
+    generateTitle?: typeof generateWandTaskTitle;
 }
 /** 任务派发配置：provider / model / thinkingEffort 三者必须同时给出且合法。 */
 export declare function parseTaskAgent(value: unknown): WandTaskAgent | null;
+/** 等待排队中的标题生成全部结束；只有测试用，避免用例轮询。 */
+export declare function whenWandTaskTitlesSettled(): Promise<void>;
 export declare function registerTaskRoutes(app: Express, deps: TaskRouteDependencies | WandStorage, sessionsLegacy?: SessionRegistry, requireAdminLegacy?: RequestHandler): void;

package/dist/server-task-routes.js

@@ -2,11 +2,36 @@ import { getDefaultModelForProvider } from "./config.js";
 import { asyncRoute } from "./express-async.js";
 import { getErrorMessage } from "./error-utils.js";
 import { parseWandTaskAgent } from "./storage.js";
-import { archiveBoardTask } from "./wand-task-sync.js";
+import { generateWandTaskTitle, provisionalTaskTitleFromDescription, TASK_TITLE_MAX_LENGTH } from "./task-title.js";
+import { resolveSystemAiContext } from "./session-ai-context.js";
+import { archiveBoardTask, syncUngroupedSessionsToBoard } from "./wand-task-sync.js";
 const STATUSES = new Set(["todo", "doing", "done"]);
 const PRIORITIES = new Set(["none", "low", "medium", "high", "urgent"]);
 const AGENT_PROVIDERS = new Set(["claude", "codex", "opencode", "grok", "qoder", "pi"]);
 const AGENT_EFFORTS = new Set(["off", "standard", "deep", "max"]);
+const TASK_BOARD_LAST_AGENT_KEY = "pref:taskBoardLastAgent";
+function defaultTaskBoardAgent() {
+    return { provider: "claude", model: "default", thinkingEffort: "off" };
+}
+/** 任务面板上次选用的 CLI 工具 / 模型 / 思考深度；从未保存过时回落到 Claude 默认。 */
+export function readTaskBoardLastAgent(storage) {
+    const raw = storage.getPreference(TASK_BOARD_LAST_AGENT_KEY, null);
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        return defaultTaskBoardAgent();
+    try {
+        return parseTaskAgent(raw) ?? defaultTaskBoardAgent();
+    }
+    catch {
+        return defaultTaskBoardAgent();
+    }
+}
+export function writeTaskBoardLastAgent(storage, agent) {
+    storage.setPreference(TASK_BOARD_LAST_AGENT_KEY, {
+        provider: agent.provider,
+        model: agent.model,
+        thinkingEffort: agent.thinkingEffort,
+    });
+}
 function dateValue(value) {
     if (value === undefined)
         return undefined;
@@ -80,6 +105,52 @@ function taskSessionSummary(session) {
 function sendTaskError(res, error, fallback) {
     res.status(400).json({ error: getErrorMessage(error, fallback) });
 }
+/**
+ * 用户没写标题时，先用描述首行当占位标题，再由后台模型总结一个更好的。
+ * 全程不阻塞创建请求：失败只是保留占位标题，不返回错误、也不覆盖用户后来改的标题。
+ * 多次建任务会排队而不是丢弃，保证每张卡片最终都会拿到标题。
+ */
+let titleGenerationChain = Promise.resolve();
+function scheduleWandTaskTitleGeneration(storage, taskId, description, options) {
+    const cwd = options.cwd || options.config?.defaultCwd || process.cwd();
+    const run = async () => {
+        try {
+            const title = await options.generateTitle(description, cwd, options.config?.language ?? "", taskTitleAiOptions(options.config));
+            const current = storage.getWandTask(taskId);
+            // 用户已经自己写了标题（原生端 / 面板编辑）就不要覆盖。
+            if (!current || current.titleSource !== "auto")
+                return;
+            const clipped = title.slice(0, TASK_TITLE_MAX_LENGTH);
+            if (!clipped || clipped === current.title)
+                return;
+            storage.updateWandTask(taskId, { title: clipped });
+        }
+        catch (error) {
+            console.error(`[WandTask] Failed to auto-generate title for ${taskId}:`, getErrorMessage(error));
+        }
+    };
+    titleGenerationChain = titleGenerationChain.then(run, run);
+}
+/** 等待排队中的标题生成全部结束；只有测试用，避免用例轮询。 */
+export function whenWandTaskTitlesSettled() {
+    return titleGenerationChain;
+}
+/** 自动生成标题没有会话上下文，按「默认 provider + 默认模型」解析，与提示词优化一致。 */
+function taskTitleAiOptions(config) {
+    if (!config)
+        return {};
+    const provider = config.defaultProvider ?? "claude";
+    const defaultSession = {
+        provider,
+        structuredState: undefined,
+        runner: undefined,
+        command: provider === "qoder" ? "qodercli" : provider,
+        selectedModel: null,
+        thinkingEffort: config.defaultThinkingEffort,
+    };
+    // resolveSystemAiContext 会在直连 API 可用且已启用时优先走 API，否则回落到 CLI。
+    return resolveSystemAiContext(defaultSession, config);
+}
 export function registerTaskRoutes(app, deps, sessionsLegacy, requireAdminLegacy) {
     // 兼容旧的 positional 调用；新代码统一用对象形式的依赖。
     const resolved = deps && typeof deps === "object" && "storage" in deps
@@ -89,31 +160,66 @@ export function registerTaskRoutes(app, deps, sessionsLegacy, requireAdminLegacy
     const guard = resolved.requireAdmin ?? ((_req, _res, next) => next());
     const dto = (task) => taskDto(resolved, task);
     app.get("/api/wand-tasks", guard, (req, res) => {
+        try {
+            syncUngroupedSessionsToBoard(storage);
+        }
+        catch (error) {
+            console.error("[WandTask] Failed to sync ungrouped sessions onto the board:", getErrorMessage(error));
+        }
         const workspaceId = typeof req.query.workspaceId === "string" ? req.query.workspaceId : undefined;
         res.json(storage.listWandTasks(workspaceId).map((task) => dto(task)));
     });
+    app.get("/api/wand-task-agent-defaults", guard, (_req, res) => {
+        res.json(readTaskBoardLastAgent(storage));
+    });
+    app.put("/api/wand-task-agent-defaults", guard, (req, res) => {
+        try {
+            const agent = parseTaskAgent(req.body);
+            if (!agent)
+                throw new Error("请选择有效的 CLI 工具。");
+            writeTaskBoardLastAgent(storage, agent);
+            res.json(agent);
+        }
+        catch (error) {
+            sendTaskError(res, error, "无法保存 Agent 默认选项。");
+        }
+    });
     app.post("/api/wand-tasks", guard, (req, res) => {
         try {
             const body = bodyObject(req.body);
-            const title = text(body.title);
-            if (!title)
-                throw new Error("任务标题不能为空。");
             const workspaceId = body.workspaceId === null ? null : text(body.workspaceId) || null;
             if (workspaceId && !storage.getWorkspace(workspaceId))
                 throw new Error("项目不存在。");
+            const description = text(body.description);
+            // 标题是可选字段：用户不写就先用描述首行占位，再由模型在后台覆盖。
+            const providedTitle = text(body.title);
+            if (!providedTitle && !description)
+                throw new Error("请填写任务标题或任务描述。");
+            const titleSource = providedTitle ? "user" : "auto";
+            const title = providedTitle || provisionalTaskTitleFromDescription(description) || "新建任务";
             const status = STATUSES.has(body.status) ? body.status : "todo";
             const priority = PRIORITIES.has(body.priority) ? body.priority : "none";
             const agent = body.agent === undefined ? null : parseTaskAgent(body.agent);
+            if (agent)
+                writeTaskBoardLastAgent(storage, agent);
             const task = storage.createWandTask({
                 workspaceId,
                 title,
-                description: text(body.description),
+                titleSource,
+                description,
                 status,
                 priority,
                 labels: labelsFrom(body.labels),
                 dueDate: dateValue(body.dueDate) ?? null,
                 agent,
             });
+            if (titleSource === "auto") {
+                scheduleWandTaskTitleGeneration(storage, task.id, description, {
+                    cwd: workspaceId ? storage.getWorkspace(workspaceId)?.cwd : undefined,
+                    config,
+                    generateTitle: resolved.generateTitle ?? generateWandTaskTitle,
+                });
+            }
             res.status(201).json(dto(task));
         }
         catch (error) {
@@ -125,10 +231,12 @@ export function registerTaskRoutes(app, deps, sessionsLegacy, requireAdminLegacy
             const body = bodyObject(req.body);
             const patch = {};
             if (body.title !== undefined) {
+                // 显式改标题（包括原生端的可编辑标题框）都算用户自己写的。
                 const value = text(body.title);
                 if (!value)
                     throw new Error("任务标题不能为空。");
                 patch.title = value;
+                patch.titleSource = "user";
             }
             if (body.description !== undefined)
                 patch.description = text(body.description);
@@ -152,8 +260,11 @@ export function registerTaskRoutes(app, deps, sessionsLegacy, requireAdminLegacy
                     throw new Error("项目不存在。");
                 patch.workspaceId = workspaceId || null;
             }
-            if (body.agent !== undefined)
+            if (body.agent !== undefined) {
                 patch.agent = parseTaskAgent(body.agent);
+                if (patch.agent)
+                    writeTaskBoardLastAgent(storage, patch.agent);
+            }
             if (body.sortOrder !== undefined && Number.isFinite(Number(body.sortOrder))) {
                 patch.sortOrder = Math.floor(Number(body.sortOrder));
             }
@@ -215,6 +326,7 @@ export function registerTaskRoutes(app, deps, sessionsLegacy, requireAdminLegacy
                 : parseTaskAgent(body.agent);
             if (!agent)
                 throw new Error("请先为该任务选择 CLI 工具。");
+            writeTaskBoardLastAgent(storage, agent);
             const workspace = task.workspaceId ? storage.getWorkspace(task.workspaceId) : null;
             if (task.workspaceId && !workspace)
                 throw new Error("任务所属项目已被删除，请重新指定。");
@@ -230,6 +342,7 @@ export function registerTaskRoutes(app, deps, sessionsLegacy, requireAdminLegacy
                 sessionSource: "automation",
                 automationId: `wand-task:${task.id}`,
                 workspaceId: task.workspaceId ?? undefined,
+                workspaceTaskId: task.workspaceTaskId ?? undefined,
             });
             storage.updateWandTask(task.id, { agent, status: task.status === "todo" ? "doing" : task.status });
             storage.bindWandTaskSession(task.id, session.id);

package/dist/server.js

@@ -260,6 +260,11 @@ function authenticateBearerAppToken(req, storage, config) {
     }
 }
 function resolveRequestServerUrl(req, config, useHttps) {
+    // 配置了公开 origin 就优先用它：TLS 在 L4 反代（nginx stream / NPM TCP stream）终止时
+    // node 只看到明文 HTTP，既没有 X-Forwarded-Proto 也没有正确的 scheme，猜不出来。
+    const configuredOrigin = normalizePublicOrigin(config.publicOrigin);
+    if (configuredOrigin)
+        return resolveAppConnectOrigin(configuredOrigin, config);
     const requestProtocol = getPublicRequestProtocol(req, useHttps ? "https" : "http");
     const requestHost = getPublicRequestHost(req, config);
     const originHeader = firstHeaderValue(req.headers.origin);
@@ -960,10 +965,11 @@ export async function startServer(config, configPath, options = {}) {
         modelCatalog,
         resolveAppConnectCode: (req) => {
             const effectivePassword = getEffectivePassword(storage, config);
+            const configuredOrigin = normalizePublicOrigin(config.publicOrigin);
             const requestProtocol = getPublicRequestProtocol(req, useHttps ? "https" : "http");
             const requestHost = getPublicRequestHost(req, config);
             const browserOrigin = normalizePublicOrigin(firstQueryStringValue(req.query.origin));
-            const serverUrl = resolveAppConnectOrigin(browserOrigin ?? `${requestProtocol}://${requestHost}`, config);
+            const serverUrl = resolveAppConnectOrigin(configuredOrigin ?? browserOrigin ?? `${requestProtocol}://${requestHost}`, config);
             const token = generateAppToken(effectivePassword, config.appSecret ?? "");
             return { code: encodeConnectCode(serverUrl, token), url: serverUrl };
         },

package/dist/storage.d.ts

@@ -121,6 +121,7 @@ export declare class WandStorage {
         workspaceId?: string | null;
         workspaceTaskId?: string | null;
         title: string;
+        titleSource?: import("./task-types.js").WandTaskTitleSource;
         description?: string;
         status?: import("./task-types.js").WandTaskStatus;
         priority?: import("./task-types.js").WandTaskPriority;
@@ -128,9 +129,10 @@ export declare class WandStorage {
         dueDate?: string | null;
         agent?: import("./task-types.js").WandTaskAgent | null;
     }): import("./task-types.js").WandTask;
-    updateWandTask(id: string, patch: Partial<Pick<import("./task-types.js").WandTask, "workspaceId" | "workspaceTaskId" | "title" | "description" | "status" | "priority" | "labels" | "dueDate" | "sortOrder" | "agent">>): import("./task-types.js").WandTask | null;
+    updateWandTask(id: string, patch: Partial<Pick<import("./task-types.js").WandTask, "workspaceId" | "workspaceTaskId" | "title" | "titleSource" | "description" | "status" | "priority" | "labels" | "dueDate" | "sortOrder" | "agent">>): import("./task-types.js").WandTask | null;
     deleteWandTask(id: string): void;
     listWandTaskSessionIds(taskId: string): string[];
+    listBoundWandTaskSessionIds(): string[];
     bindWandTaskSession(taskId: string, sessionId: string): void;
     unbindWandTaskSession(taskId: string, sessionId: string): void;
     listGithubIssueBindings(owner: string, repo: string, issueNumber: number): Array<{

package/dist/storage.js

@@ -719,6 +719,7 @@ const INIT_SQL = `
     sort_order INTEGER NOT NULL DEFAULT 0,
     agent_json TEXT,
     workspace_task_id TEXT,
+    title_source TEXT,
     created_at TEXT NOT NULL,
     updated_at TEXT NOT NULL,
     FOREIGN KEY (workspace_id) REFERENCES workspaces(id) ON DELETE SET NULL
@@ -746,6 +747,9 @@ function ensureWandTaskSchema(db) {
         db.exec("ALTER TABLE wand_tasks ADD COLUMN agent_json TEXT");
     if (columns.length > 0 && !names.has("workspace_task_id"))
         db.exec("ALTER TABLE wand_tasks ADD COLUMN workspace_task_id TEXT");
+    // 标题来源：'user' = 用户手写，'auto' = 由描述自动生成。只加列，历史行保持 NULL（读取时视为 user）。
+    if (columns.length > 0 && !names.has("title_source"))
+        db.exec("ALTER TABLE wand_tasks ADD COLUMN title_source TEXT");
     if (columns.length > 0) {
         // Index creation must wait until the column exists on legacy databases.
         // INIT_SQL cannot create it: CREATE TABLE IF NOT EXISTS is a no-op on old
@@ -1152,7 +1156,7 @@ export class WandStorage {
         });
     }
     listWandTasks(workspaceId) {
-        const rows = this.db.prepare(`SELECT id, identifier, workspace_id, workspace_task_id, title, description, status, priority, labels_json, due_date, sort_order, agent_json, created_at, updated_at
+        const rows = this.db.prepare(`SELECT id, identifier, workspace_id, workspace_task_id, title, title_source, description, status, priority, labels_json, due_date, sort_order, agent_json, created_at, updated_at
        FROM wand_tasks ${workspaceId === undefined ? "" : "WHERE workspace_id IS ?"}
        ORDER BY status, sort_order, updated_at DESC`).all(...(workspaceId === undefined ? [] : [workspaceId]));
         return rows.map((row) => this.mapWandTaskRow(row));
@@ -1164,6 +1168,7 @@ export class WandStorage {
             workspaceId: typeof row.workspace_id === "string" ? row.workspace_id : null,
             workspaceTaskId: typeof row.workspace_task_id === "string" && row.workspace_task_id ? row.workspace_task_id : null,
             title: String(row.title),
+            titleSource: row.title_source === "auto" ? "auto" : "user",
             description: String(row.description ?? ""),
             status: row.status === "doing" || row.status === "done" ? row.status : "todo",
             priority: row.priority === "low" || row.priority === "medium" || row.priority === "high" || row.priority === "urgent" ? row.priority : "none",
@@ -1179,12 +1184,12 @@ export class WandStorage {
         return this.listWandTasks().find((task) => task.id === id) ?? null;
     }
     getWandTaskByWorkspaceTaskId(workspaceTaskId) {
-        const row = this.db.prepare(`SELECT id, identifier, workspace_id, workspace_task_id, title, description, status, priority, labels_json, due_date, sort_order, agent_json, created_at, updated_at
+        const row = this.db.prepare(`SELECT id, identifier, workspace_id, workspace_task_id, title, title_source, description, status, priority, labels_json, due_date, sort_order, agent_json, created_at, updated_at
        FROM wand_tasks WHERE workspace_task_id = ? ORDER BY updated_at DESC LIMIT 1`).get(workspaceTaskId);
         return row ? this.mapWandTaskRow(row) : null;
     }
     findUnlinkedWandTask(workspaceId, title) {
-        const row = this.db.prepare(`SELECT id, identifier, workspace_id, workspace_task_id, title, description, status, priority, labels_json, due_date, sort_order, agent_json, created_at, updated_at
+        const row = this.db.prepare(`SELECT id, identifier, workspace_id, workspace_task_id, title, title_source, description, status, priority, labels_json, due_date, sort_order, agent_json, created_at, updated_at
        FROM wand_tasks
        WHERE workspace_id IS ? AND title = ? AND (workspace_task_id IS NULL OR workspace_task_id = '')
        ORDER BY updated_at DESC LIMIT 1`).get(workspaceId, title);
@@ -1198,7 +1203,7 @@ export class WandStorage {
         const max = this.db.prepare("SELECT COALESCE(MAX(sort_order), -1) AS value FROM wand_tasks WHERE workspace_id IS ? AND status = ?").get(input.workspaceId ?? null, status);
         const numberRow = this.db.prepare("SELECT COALESCE(MAX(CAST(substr(identifier, 6) AS INTEGER)), 0) AS value FROM wand_tasks WHERE identifier GLOB 'TASK-[0-9]*'").get();
         const identifier = `TASK-${(numberRow?.value ?? 0) + 1}`;
-        this.db.prepare(`INSERT INTO wand_tasks (id, identifier, workspace_id, workspace_task_id, title, description, status, priority, labels_json, due_date, sort_order, agent_json, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, identifier, input.workspaceId ?? null, input.workspaceTaskId ?? null, input.title, input.description ?? "", status, priority, JSON.stringify(input.labels ?? []), input.dueDate ?? null, (max?.value ?? -1) + 1, input.agent ? JSON.stringify(input.agent) : null, now, now);
+        this.db.prepare(`INSERT INTO wand_tasks (id, identifier, workspace_id, workspace_task_id, title, title_source, description, status, priority, labels_json, due_date, sort_order, agent_json, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, identifier, input.workspaceId ?? null, input.workspaceTaskId ?? null, input.title, input.titleSource ?? "user", input.description ?? "", status, priority, JSON.stringify(input.labels ?? []), input.dueDate ?? null, (max?.value ?? -1) + 1, input.agent ? JSON.stringify(input.agent) : null, now, now);
         return this.getWandTask(id);
     }
     updateWandTask(id, patch) {
@@ -1206,7 +1211,7 @@ export class WandStorage {
         if (!current)
             return null;
         const next = { ...current, ...patch, updatedAt: nowIso() };
-        this.db.prepare(`UPDATE wand_tasks SET workspace_id = ?, workspace_task_id = ?, title = ?, description = ?, status = ?, priority = ?, labels_json = ?, due_date = ?, sort_order = ?, agent_json = ?, updated_at = ? WHERE id = ?`).run(next.workspaceId, next.workspaceTaskId, next.title, next.description, next.status, next.priority, JSON.stringify(next.labels), next.dueDate, next.sortOrder, next.agent ? JSON.stringify(next.agent) : null, next.updatedAt, id);
+        this.db.prepare(`UPDATE wand_tasks SET workspace_id = ?, workspace_task_id = ?, title = ?, title_source = ?, description = ?, status = ?, priority = ?, labels_json = ?, due_date = ?, sort_order = ?, agent_json = ?, updated_at = ? WHERE id = ?`).run(next.workspaceId, next.workspaceTaskId, next.title, next.titleSource, next.description, next.status, next.priority, JSON.stringify(next.labels), next.dueDate, next.sortOrder, next.agent ? JSON.stringify(next.agent) : null, next.updatedAt, id);
         return next;
     }
     deleteWandTask(id) { this.db.prepare("DELETE FROM wand_tasks WHERE id = ?").run(id); }
@@ -1214,6 +1219,10 @@ export class WandStorage {
         const rows = this.db.prepare("SELECT session_id FROM wand_task_sessions WHERE task_id = ? ORDER BY rowid ASC, session_id ASC").all(taskId);
         return rows.map((row) => row.session_id);
     }
+    listBoundWandTaskSessionIds() {
+        const rows = this.db.prepare("SELECT session_id FROM wand_task_sessions").all();
+        return rows.map((row) => row.session_id);
+    }
     bindWandTaskSession(taskId, sessionId) {
         if (!this.getWandTask(taskId))
             throw new Error("未找到该任务。");

package/dist/task-title.d.ts

@@ -0,0 +1,14 @@
+import { type QuickCommitAiOptions } from "./git-quick-commit.js";
+/** 任务标题留空时由描述自动生成；面板上显示得下，也不至于截断成半句话。 */
+export declare const TASK_TITLE_MAX_LENGTH = 40;
+/**
+ * 描述已经到达客户端之后立刻可用的标题：不依赖模型，也不等网络。
+ * 后台自动生成成功后再覆盖它；失败或超时就保留这个兜底。
+ */
+export declare function provisionalTaskTitleFromDescription(description: string): string;
+/** 模型输出可能带引号、代码块或「标题：」前缀，逐层剥掉再按单行裁剪。 */
+export declare function parseGeneratedTaskTitle(raw: string): string;
+/** 识别“这不像标题”的输出：报错文案、整段句子、多行解释。 */
+export declare function isPlausibleTaskTitle(value: string): boolean;
+/** 由任务描述总结一个标题；模型的输出永远只作为候选，由调用方决定是否落库。 */
+export declare function generateWandTaskTitle(description: string, cwd: string, language?: string, ai?: QuickCommitAiOptions): Promise<string>;

package/dist/task-title.js

@@ -0,0 +1,96 @@
+import { callConfiguredAiText } from "./git-quick-commit.js";
+/** 任务标题留空时由描述自动生成；面板上显示得下，也不至于截断成半句话。 */
+export const TASK_TITLE_MAX_LENGTH = 40;
+const DESCRIPTION_HINT_MAX = 2_000;
+function clip(value, maxLength = TASK_TITLE_MAX_LENGTH) {
+    if (value.length <= maxLength)
+        return value;
+    const sliced = value.slice(0, maxLength);
+    const lastSpace = sliced.lastIndexOf(" ");
+    if (lastSpace >= Math.floor(maxLength * 0.55))
+        return sliced.slice(0, lastSpace);
+    return sliced;
+}
+function firstMeaningfulLine(description) {
+    const lines = description
+        .split(/\r?\n/)
+        .map((line) => line
+        // Markdown 列表 / 标题 / 引用符不能变成标题的一部分。
+        .replace(/^\s*(?:[-*+>]+|\d+[.)]|#{1,6})\s*/, "")
+        .replace(/\s+/g, " ")
+        .trim())
+        .filter(Boolean);
+    const line = lines.find((candidate) => candidate.length >= 2) ?? lines[0] ?? "";
+    return line.replace(/[：:；;，,。.]+$/, "").trim();
+}
+/**
+ * 描述已经到达客户端之后立刻可用的标题：不依赖模型，也不等网络。
+ * 后台自动生成成功后再覆盖它；失败或超时就保留这个兜底。
+ */
+export function provisionalTaskTitleFromDescription(description) {
+    return clip(firstMeaningfulLine(description));
+}
+/** 模型输出可能带引号、代码块或「标题：」前缀，逐层剥掉再按单行裁剪。 */
+export function parseGeneratedTaskTitle(raw) {
+    return clip(stripGeneratedTitle(raw));
+}
+function stripGeneratedTitle(raw) {
+    const withoutFences = raw.trim().replace(/^```(?:json|text)?\s*/i, "").replace(/\s*```$/i, "").trim();
+    const firstLine = withoutFences.split(/\r?\n/).map((line) => line.trim()).find(Boolean) ?? "";
+    const withoutLabel = firstLine.replace(/^(?:任务)?标题\s*[:：]\s*/, "");
+    const unquoted = withoutLabel.replace(/^["'`“”『「]+|["'`“”』」]+$/g, "").trim();
+    return unquoted.replace(/[。.]+$/, "").trim();
+}
+/**
+ * CLI 把 provider 自己的报错（模型不可用、限流、鉴权失败）当成功结果返回时，
+ * 整句话会原样变成任务标题。这些字符串一律不能当标题落库。
+ */
+const TITLE_REJECT_PATTERNS = [
+    /\b(?:i(?:'| a)?m )?sorry\b/i,
+    /\bthere(?:'| i)?s?\s+an?\s+issue\b/i,
+    /\b(?:api|model|provider|authentication|rate)[ _-]?(?:error|limit|key|quota)\b/i,
+    /\b(?:invalid|missing|expired)\b[^.]{0,24}\b(?:key|token|api|model|credential)\b/i,
+    /\b(?:unauthorized|forbidden|permission denied|quota exceeded|not found|timed? ?out)\b/i,
+    /\b(?:error|exception|failed|failure)\s*[:：]/i,
+    /^(?:检索|抱歉|对不起|无法|不能|错错|错误|失败|请求超时|服务不可用)/,
+];
+/** 识别“这不像标题”的输出：报错文案、整段句子、多行解释。 */
+export function isPlausibleTaskTitle(value) {
+    const title = value.replace(/\s+/g, " ").trim();
+    if (!title)
+        return false;
+    // 超过一行标题的长度上限就不再是标题，而是解释。
+    if (title.length > TASK_TITLE_MAX_LENGTH)
+        return false;
+    if (TITLE_REJECT_PATTERNS.some((pattern) => pattern.test(title)))
+        return false;
+    // 标题是一行短语：出现句末标点，或长句里带逗号分号，都说明这是解释而不是标题。
+    if (/[。！？!?]/.test(title))
+        return false;
+    if (title.length > 24 && /[，,；;]/.test(title))
+        return false;
+    return true;
+}
+/** 由任务描述总结一个标题；模型的输出永远只作为候选，由调用方决定是否落库。 */
+export async function generateWandTaskTitle(description, cwd, language = "", ai = {}) {
+    const input = description.trim().slice(0, DESCRIPTION_HINT_MAX);
+    if (!input)
+        throw new Error("没有可总结的任务描述。");
+    const outputLanguage = language.trim() || "与描述相同的语言";
+    const prompt = [
+        "根据下面的任务描述，写一个用于任务列表的具体标题。",
+        `使用${outputLanguage}输出。`,
+        "只输出标题本身：一行纯文本，不要引号、不要 Markdown、不要编号、不要「标题：」这类前缀、不要任何解释。",
+        "不超过 20 个字，必须点出描述里的具体对象或动作，不要使用「任务」「待办」「关于」「请求」等空泛词。",
+        "",
+        "任务描述：",
+        input,
+    ].join("\n");
+    const raw = await callConfiguredAiText(prompt, cwd || process.cwd(), language, ai);
+    const stripped = stripGeneratedTitle(raw);
+    // 拿到报错文案 / 整段解释时宁可保留占位标题，也不能把垃圾写进看板。
+    // 先判可信度再裁剪：截断过的长句看起来就像标题，会绕过长度检查。
+    if (!isPlausibleTaskTitle(stripped))
+        throw new Error("模型返回的任务标题不可用。");
+    return clip(stripped);
+}

package/dist/task-types.d.ts

@@ -11,6 +11,8 @@ export interface WandTaskAgent {
     model: WandTaskAgentModel;
     thinkingEffort: WandTaskAgentEffort;
 }
+/** 任务标题来源；标题是可选字段，留空时由服务端按描述自动生成。 */
+export type WandTaskTitleSource = "user" | "auto";
 export interface WandTask {
     id: string;
     workspaceId: string | null;
@@ -18,6 +20,8 @@ export interface WandTask {
     workspaceTaskId: string | null;
     identifier: string;
     title: string;
+    /** 'user' = 用户自己填的标题；'auto' = 用户留空后按描述自动生成。 */
+    titleSource: WandTaskTitleSource;
     description: string;
     status: WandTaskStatus;
     priority: WandTaskPriority;

package/dist/types.d.ts

@@ -89,6 +89,17 @@ export interface WandConfig {
         certPath?: string;
         keyPath?: string;
     };
+    /**
+     * 对外公开的访问地址（如 `https://home.example.com:8443`）。
+     *
+     * TLS 由 L4 反代（nginx stream / Nginx Proxy Manager 的 TCP stream）终止时，node 收到的是
+     * 明文 HTTP，既没有 `X-Forwarded-Proto` 也没有真实 scheme，`/api/app-connect-code` 与
+     * `/api/login` 的 `serverUrl` 会把 `https://host:tls-port` 误判成 `http://host:tls-port`，
+     * 手机扫描连接码后对 TLS 端口发明文请求，报“连不上服务端”。
+     *
+     * 填了就以这里为准（含 scheme），不再猜测。留空则沿用请求头 / 浏览器 origin 推断。
+     */
+    publicOrigin?: string;
     password: string;
     /** 新建会话时默认使用的 Provider。 */
     defaultProvider?: SessionProvider;

package/dist/wand-task-sync.d.ts

@@ -1,8 +1,16 @@
 import type { WandStorage } from "./storage.js";
 import type { WandTask } from "./task-types.js";
-import type { Workspace, WorkspaceTask } from "./types.js";
+import type { SessionSnapshot, Workspace, WorkspaceTask } from "./types.js";
+export declare function isUnnamedWorkspaceTaskName(name: string): boolean;
+/** 从未分组会话的标题 / 描述 / 首条用户消息里抽出看板标题。 */
+export declare function boardTitleFromSession(session: SessionSnapshot): string;
 /** 侧栏工作任务与看板卡片对账：已关联则复用，同项目同名未关联则挂上，否则新建。 */
-export declare function ensureBoardTaskForWorkspaceTask(storage: WandStorage, task: WorkspaceTask, workspace: Workspace): WandTask;
+export declare function ensureBoardTaskForWorkspaceTask(storage: WandStorage, task: WorkspaceTask, workspace: Workspace): WandTask | null;
+/**
+ * 把历史未分组会话补到看板：用会话标题/首条消息当标题，绑上会话，放进「进行中」。
+ * 幂等，打开看板列表时调用。
+ */
+export declare function syncUngroupedSessionsToBoard(storage: WandStorage): void;
 /** 看板归档：卡片进入已完成，并同步把关联的侧栏工作任务标成 done（不删会话）。 */
 export declare function archiveBoardTask(storage: WandStorage, id: string): WandTask | null;
 /** 侧栏工作任务完成/删除时，把对应看板卡片标成已完成。 */