@co0ontty/wand 4.55.3 → 4.56.0-beta.ga71d7db

package/dist/server-workspace-routes.js

@@ -8,7 +8,7 @@ import { checkSessionWorktreeMergeabilityAsync, cleanupWorktreeSync, prepareSess
 import { collectSessionTopicBlocklist } from "./session-topic.js";
 import { resolveSessionDisplayTitle } from "./session-transport.js";
 import { GLOBAL_WORKSPACE_ID } from "./types.js";
-import { attachUnboundSessionsToWorkspace, backfillSessionWorkspaces, } from "./workspace-binding.js";
+import { attachUnboundSessionsToWorkspace, backfillSessionWorkspaces, normalizeProjectCwd, projectCwdForSession, } from "./workspace-binding.js";
 const PROVIDERS = new Set(["claude", "codex", "opencode", "grok", "qoder", "pi"]);
 function workspaceSessionTitle(session, names = {}) {
     return resolveSessionDisplayTitle(session, collectSessionTopicBlocklist({
@@ -71,12 +71,15 @@ function taskRuntimeCwd(task, workspace) {
 }
 function createTaskForWorkspace(storage, workspace, body) {
     const name = typeof body.name === "string" ? body.name.trim() : "";
-    if (!name)
-        throw new Error("请输入任务名称。");
+    const taskName = name || "未命名任务";
     let mountedCwd;
     if (body.cwd !== undefined && body.cwd !== null && String(body.cwd).trim()) {
         mountedCwd = resolveWorkspaceCwd(body.cwd);
     }
+    if (mountedCwd && !isGlobalWorkspace(workspace)
+        && normalizeProjectCwd(mountedCwd) !== normalizeProjectCwd(workspace.cwd)) {
+        throw new Error("任务目录与所属项目不一致，请先选择对应项目，或创建独立任务。");
+    }
     const baseRef = typeof body.baseRef === "string" && body.baseRef.trim() ? body.baseRef.trim() : undefined;
     const runCwd = mountedCwd ?? workspace.cwd;
     const wantWorktree = body.worktree === true || (body.worktree !== false && !isGlobalWorkspace(workspace));
@@ -87,7 +90,7 @@ function createTaskForWorkspace(storage, workspace, body) {
             const setup = prepareSessionWorktree({
                 cwd: runCwd,
                 sessionId: crypto.randomUUID(),
-                spec: { taskName: name, baseRef },
+                spec: { taskName, baseRef },
             });
             worktree = setup.worktree;
         }
@@ -98,9 +101,9 @@ function createTaskForWorkspace(storage, workspace, body) {
     const storedCwd = mountedCwd && mountedCwd !== workspace.cwd ? mountedCwd : undefined;
     const task = storage.createWorkspaceTask({
         workspaceId: workspace.id,
-        name,
-        worktree,
+        name: taskName,
         cwd: storedCwd,
+        worktree,
     });
     return {
         task,
@@ -392,27 +395,61 @@ export function registerWorkspaceRoutes(app, storage, sessions) {
                 workspaceName: global ? "全局" : workspace.name,
                 workspaceCwd: workspace.cwd,
                 ...(global ? { global: true } : {}),
-                tasks: storage.listWorkspaceTasks(workspace.id)
-                    .slice(0, taskLimit ?? undefined)
-                    .map((task) => {
-                    const allSessions = storage.listSessionsByWorkspaceTask(task.id);
-                    const sessions = allSessions
-                        .slice(0, sessionLimit ?? undefined)
-                        .map((session) => ({
-                        ...summarize(session, { taskName: task.name, workspaceName: global ? undefined : workspace.name }),
-                        workspaceTaskId: task.id,
-                    }));
-                    return {
-                        ...task,
-                        cwd: taskRuntimeCwd(task, workspace),
-                        isolated: task.worktree !== null,
-                        sessions,
-                        totalSessions: allSessions.length,
-                    };
-                }),
+                tasks: [],
                 standaloneSessions: [],
             });
         }
+        const syntheticGroupForCwd = (cwd) => {
+            const normalized = normalizeProjectCwd(cwd);
+            const existingProject = [...groups.values()].find((candidate) => !candidate.synthetic
+                && !candidate.global && normalizeProjectCwd(candidate.workspaceCwd) === normalized);
+            if (existingProject)
+                return existingProject;
+            const id = `cwd:${normalized}`;
+            const existing = groups.get(id);
+            if (existing)
+                return existing;
+            const created = {
+                workspaceId: id,
+                workspaceName: normalized.split("/").filter(Boolean).at(-1) || normalized,
+                workspaceCwd: normalized,
+                synthetic: true,
+                tasks: [],
+                standaloneSessions: [],
+            };
+            groups.set(id, created);
+            return created;
+        };
+        const appendTask = (target, workspace, task) => {
+            const allSessions = storage.listSessionsByWorkspaceTask(task.id);
+            const sessions = allSessions
+                .slice(0, sessionLimit ?? undefined)
+                .map((session) => ({
+                ...summarize(session, { taskName: task.name, workspaceName: isGlobalWorkspace(workspace) ? undefined : workspace.name }),
+                workspaceTaskId: task.id,
+            }));
+            target.tasks.push({
+                ...task,
+                cwd: taskRuntimeCwd(task, workspace),
+                isolated: task.worktree !== null,
+                sessions,
+                totalSessions: allSessions.length,
+            });
+        };
+        for (const workspace of visibleWorkspaces) {
+            const base = groups.get(workspace.id);
+            if (!base)
+                continue;
+            const global = isGlobalWorkspace(workspace);
+            for (const task of storage.listWorkspaceTasks(workspace.id).slice(0, taskLimit ?? undefined)) {
+                const taskCwd = taskRuntimeCwd(task, workspace);
+                const target = global && taskCwd
+                    && normalizeProjectCwd(taskCwd) !== normalizeProjectCwd(workspace.cwd)
+                    ? syntheticGroupForCwd(taskCwd)
+                    : base;
+                appendTask(target, workspace, task);
+            }
+        }
         const taskBoundSessionIds = new Set();
         for (const workspace of workspaces) {
             for (const task of storage.listWorkspaceTasks(workspace.id)) {
@@ -424,10 +461,16 @@ export function registerWorkspaceRoutes(app, storage, sessions) {
             if (taskBoundSessionIds.has(session.id))
                 continue;
             const direct = session.workspaceId ? groups.get(session.workspaceId) : undefined;
-            let group = direct && !direct.synthetic ? direct : undefined;
-            const resolved = session.cwd ? path.resolve(session.cwd) : "";
+            const resolved = projectCwdForSession(session);
+            // 持久化的 workspaceId 可能来自旧目录或目录迁移；path 与项目目录不一致时，
+            // 必须按当前实际目录归类，避免不同项目的会话混入同一组。
+            let group = direct && !direct.synthetic
+                && normalizeProjectCwd(direct.workspaceCwd) === resolved
+                ? direct
+                : undefined;
             if (!group && resolved) {
-                const cwdMatches = [...groups.values()].filter((candidate) => !candidate.synthetic && candidate.workspaceCwd === resolved);
+                const cwdMatches = [...groups.values()].filter((candidate) => !candidate.synthetic
+                    && normalizeProjectCwd(candidate.workspaceCwd) === resolved);
                 group = cwdMatches.find((candidate) => !candidate.global) ?? cwdMatches[0];
             }
             // 过滤模式下不创建合成组：不属于目标目录的会话直接排除。

package/dist/server.js

@@ -22,6 +22,10 @@ import { resolveSessionAiContext, resolveSystemAiContext } from "./session-ai-co
 import { StructuredSessionManager } from "./structured-session-manager.js";
 import { recordRecentPath, registerFileRoutes } from "./server-file-routes.js";
 import { registerSettingsRoutes } from "./server-settings-routes.js";
+import { registerGithubRoutes } from "./server-github-routes.js";
+import { startTaskboardBridge } from "./taskboard-bridge.js";
+import { registerTaskRoutes } from "./server-task-routes.js";
+import { getGithubConnectorStatus } from "./github-connector.js";
 import { registerMissionRoutes } from "./server-mission-routes.js";
 import { Missions } from "./missions.js";
 import { refreshProviderCliUpdateState, registerAdminUpdateRoutes, registerPublicUpdateRoutes, ServerUpdateState, } from "./server-update-routes.js";
@@ -554,6 +558,20 @@ export async function startServer(config, configPath, options = {}) {
     const requireSessions = buildRequireScope("sessions");
     const requireFiles = buildRequireScope("files");
     const requirePasswordVault = buildRequireScope("password-vault");
+    const taskboardBridge = await startTaskboardBridge(configDir, storage, sessionRegistry, structuredSessions, config.defaultCwd);
+    app.use("/taskboard", (req, res, next) => {
+        // Taskboard's immutable Vite assets are safe to serve without the Wand
+        // session cookie. This matters behind HTTPS reverse proxies where iframe
+        // subresource requests may not carry the parent authentication cookie.
+        const staticAsset = req.path.startsWith("/assets/")
+            || /^\/[^/]+\.(?:css|js|map|svg|png|jpg|jpeg|webp|ico)$/.test(req.path);
+        if (staticAsset) {
+            taskboardBridge.handler(req, res, next);
+            return;
+        }
+        requireAuth(req, res, next);
+    });
+    app.use("/taskboard", taskboardBridge.handler);
     // Route-specific parsers must run before the global parser. Once body-parser
     // has consumed a request, a later express.json() cannot tighten or widen it.
     app.use("/api/optimize-prompt", express.json({ limit: "256kb" }));
@@ -953,6 +971,7 @@ export async function startServer(config, configPath, options = {}) {
         getCachedUpdateInfo: () => cachedUpdateInfo,
         getUpdateChannel,
         getDistributionSettings,
+        getGithubConnector: () => getGithubConnectorStatus(storage),
         modelCatalog,
         resolveAppConnectCode: (req) => {
             const effectivePassword = getEffectivePassword(storage, config);
@@ -964,6 +983,8 @@ export async function startServer(config, configPath, options = {}) {
             return { code: encodeConnectCode(serverUrl, token), url: serverUrl };
         },
     });
+    registerGithubRoutes(app, { storage, requireAdmin, sessions: sessionRegistry });
+    registerTaskRoutes(app, storage, sessionRegistry, requireAdmin);
     registerAdminUpdateRoutes(app, {
         storage,
         config,
@@ -1565,6 +1586,10 @@ export async function startServer(config, configPath, options = {}) {
                 wss.close();
             }
             catch { /* ignore */ }
+            try {
+                await taskboardBridge.close();
+            }
+            catch { /* best-effort shutdown */ }
             try {
                 await serverClosed;
             }

package/dist/storage.d.ts

@@ -1,6 +1,13 @@
 import { SessionSnapshot, ConversationTurn, StructuredSessionState, Workspace, LayoutNode, TaskWindowLayout, WorkspaceDefaultProvider, WorkspaceKind, WorkspaceTask, WorkspaceTaskWorktree, WorkspaceTaskStatus } from "./types.js";
 import type { AgentActivityItem, Mission, MissionAttempt, MissionReviewComment, MissionReviewStatus, MissionStatus } from "./mission-types.js";
 import { type PasswordVault, type PasswordVaultItem, type PasswordVaultItemFilter, type PasswordVaultItemInput } from "./password-manager.js";
+export interface ConnectorMeta {
+    provider: string;
+    apiUrl: string | null;
+    username: string | null;
+    connectedAt: string | null;
+    updatedAt: string;
+}
 type AuthPrincipalKind = "browser-admin" | "connected-app";
 export type AuthScope = "admin" | "sessions" | "files" | "password-vault" | "session-preferences";
 export interface AuthPrincipal {
@@ -91,6 +98,31 @@ export declare class WandStorage {
     deleteWorkspaceTask(id: string, options?: {
         cascade?: boolean;
     }): void;
+    listWandTasks(workspaceId?: string | null): import("./task-types.js").WandTask[];
+    getWandTask(id: string): import("./task-types.js").WandTask | null;
+    createWandTask(input: {
+        workspaceId?: string | null;
+        title: string;
+        description?: string;
+        status?: import("./task-types.js").WandTaskStatus;
+        priority?: import("./task-types.js").WandTaskPriority;
+        labels?: string[];
+        dueDate?: string | null;
+    }): import("./task-types.js").WandTask;
+    updateWandTask(id: string, patch: Partial<Pick<import("./task-types.js").WandTask, "workspaceId" | "title" | "description" | "status" | "priority" | "labels" | "dueDate" | "sortOrder">>): import("./task-types.js").WandTask | null;
+    deleteWandTask(id: string): void;
+    listWandTaskSessionIds(taskId: string): string[];
+    bindWandTaskSession(taskId: string, sessionId: string): void;
+    unbindWandTaskSession(taskId: string, sessionId: string): void;
+    bindTaskboardTaskSession(taskId: string, sessionId: string): void;
+    listTaskboardTaskSessions(taskId: string): string[];
+    unbindTaskboardTaskSession(taskId: string, sessionId: string): void;
+    listGithubIssueBindings(owner: string, repo: string, issueNumber: number): Array<{
+        sessionId: string;
+        boundAt: string;
+    }>;
+    bindGithubIssueSession(owner: string, repo: string, issueNumber: number, sessionId: string): void;
+    unbindGithubIssueSession(owner: string, repo: string, issueNumber: number, sessionId: string): void;
     listSessionsByWorkspaceTask(taskId: string): SessionSnapshot[];
     setSessionWorkspaceTaskId(sessionId: string, taskId: string | null): void;
     /** Get password from database */
@@ -115,6 +147,16 @@ export declare class WandStorage {
     updatePasswordItem(id: string, input: PasswordVaultItemInput): PasswordVaultItem | null;
     touchPasswordItem(id: string): PasswordVaultItem | null;
     deletePasswordItem(id: string): boolean;
+    getConnectorToken(provider: string): string | null;
+    getConnectorMeta(provider: string): ConnectorMeta | null;
+    saveConnector(provider: string, input: {
+        token?: string | null;
+        apiUrl?: string | null;
+        username?: string | null;
+        markConnected?: boolean;
+    }): ConnectorMeta;
+    deleteConnector(provider: string): boolean;
+    private encryptConnectorToken;
     saveAuthSession(token: string, expiresAt: number, principal?: AuthPrincipal): void;
     getAuthSession(token: string): PersistedAuthSession | null;
     deleteAuthSession(token: string): void;

package/dist/storage.js

@@ -545,6 +545,16 @@ const INIT_SQL = `
     updated_at TEXT NOT NULL
   );
 
+  CREATE TABLE IF NOT EXISTS connectors (
+    provider TEXT PRIMARY KEY,
+    token TEXT NOT NULL DEFAULT '',
+    api_url TEXT NOT NULL DEFAULT '',
+    username TEXT,
+    connected_at TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+
   CREATE TABLE IF NOT EXISTS password_items (
     id TEXT PRIMARY KEY,
     vault_id TEXT NOT NULL,
@@ -663,7 +673,65 @@ const INIT_SQL = `
 
   CREATE INDEX IF NOT EXISTS idx_workspace_tasks_workspace ON workspace_tasks(workspace_id);
   CREATE INDEX IF NOT EXISTS idx_workspace_tasks_last_opened ON workspace_tasks(last_opened_at);
+
+  CREATE TABLE IF NOT EXISTS github_issue_bindings (
+    owner TEXT NOT NULL,
+    repo TEXT NOT NULL,
+    issue_number INTEGER NOT NULL,
+    session_id TEXT NOT NULL,
+    bound_at TEXT NOT NULL,
+    PRIMARY KEY (owner, repo, issue_number, session_id),
+    FOREIGN KEY (session_id) REFERENCES command_sessions(id) ON DELETE CASCADE
+  );
+  CREATE INDEX IF NOT EXISTS idx_github_issue_bindings_session ON github_issue_bindings(session_id);
+
+  CREATE TABLE IF NOT EXISTS wand_tasks (
+    id TEXT PRIMARY KEY,
+    identifier TEXT,
+    workspace_id TEXT,
+    title TEXT NOT NULL,
+    description TEXT NOT NULL DEFAULT '',
+    status TEXT NOT NULL DEFAULT 'todo',
+    priority TEXT NOT NULL DEFAULT 'none',
+    labels_json TEXT NOT NULL DEFAULT '[]',
+    due_date TEXT,
+    sort_order INTEGER NOT NULL DEFAULT 0,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    FOREIGN KEY (workspace_id) REFERENCES workspaces(id) ON DELETE SET NULL
+  );
+  CREATE INDEX IF NOT EXISTS idx_wand_tasks_board ON wand_tasks(workspace_id, status, sort_order, updated_at);
+  CREATE TABLE IF NOT EXISTS wand_task_sessions (
+    task_id TEXT NOT NULL,
+    session_id TEXT NOT NULL,
+    bound_at TEXT NOT NULL,
+    PRIMARY KEY (task_id, session_id),
+    FOREIGN KEY (task_id) REFERENCES wand_tasks(id) ON DELETE CASCADE,
+    FOREIGN KEY (session_id) REFERENCES command_sessions(id) ON DELETE CASCADE
+  );
+  CREATE INDEX IF NOT EXISTS idx_wand_task_sessions_session ON wand_task_sessions(session_id);
+  CREATE TABLE IF NOT EXISTS taskboard_session_bindings (
+    task_id TEXT NOT NULL,
+    session_id TEXT NOT NULL,
+    bound_at TEXT NOT NULL,
+    PRIMARY KEY (task_id, session_id),
+    FOREIGN KEY (session_id) REFERENCES command_sessions(id) ON DELETE CASCADE
+  );
+  CREATE INDEX IF NOT EXISTS idx_taskboard_session_bindings_session ON taskboard_session_bindings(session_id);
 `;
+function ensureWandTaskSchema(db) {
+    const columns = db.prepare("PRAGMA table_info(wand_tasks)").all();
+    const names = new Set(columns.map((column) => column.name));
+    if (columns.length > 0 && !names.has("identifier"))
+        db.exec("ALTER TABLE wand_tasks ADD COLUMN identifier TEXT");
+    if (columns.length > 0 && !names.has("due_date"))
+        db.exec("ALTER TABLE wand_tasks ADD COLUMN due_date TEXT");
+    if (columns.length > 0) {
+        const rows = db.prepare("SELECT id FROM wand_tasks WHERE identifier IS NULL OR identifier = '' ORDER BY created_at, id").all();
+        const update = db.prepare("UPDATE wand_tasks SET identifier = ? WHERE id = ?");
+        rows.forEach((row, index) => update.run(`TASK-${index + 1}`, row.id));
+    }
+}
 function ensureWorkspaceSchema(db) {
     const workspaceColumns = db.prepare("PRAGMA table_info(workspaces)").all();
     const workspaceNames = new Set(workspaceColumns.map((column) => column.name));
@@ -676,6 +744,23 @@ function ensureWorkspaceSchema(db) {
         db.exec("ALTER TABLE workspace_tasks ADD COLUMN cwd TEXT");
     }
 }
+function ensureConnectorSchema(db) {
+    // The table is created by INIT_SQL for new databases; this repairs an
+    // existing wand.db that predates the connector feature (additive-only).
+    const columns = db.prepare("PRAGMA table_info(connectors)").all();
+    const names = new Set(columns.map((column) => column.name));
+    if (names.size === 0)
+        return;
+    const migrations = [
+        ["api_url", "ALTER TABLE connectors ADD COLUMN api_url TEXT NOT NULL DEFAULT ''"],
+        ["username", "ALTER TABLE connectors ADD COLUMN username TEXT"],
+        ["connected_at", "ALTER TABLE connectors ADD COLUMN connected_at TEXT"],
+    ];
+    for (const [column, sql] of migrations) {
+        if (!names.has(column))
+            db.exec(sql);
+    }
+}
 export function ensureDatabaseFile(dbPath) {
     const dir = path.dirname(dbPath);
     mkdirSync(dir, { recursive: true, mode: 0o700 });
@@ -686,6 +771,7 @@ export function ensureDatabaseFile(dbPath) {
     ensureAuthSessionSchema(db);
     ensureCommandSessionSchema(db);
     ensureWorkspaceSchema(db);
+    ensureConnectorSchema(db);
     {
         const missionColumns = db.prepare("PRAGMA table_info(missions)").all();
         if (missionColumns.length > 0 && !missionColumns.some((column) => column.name === "task_id")) {
@@ -710,6 +796,8 @@ export class WandStorage {
         ensureAuthSessionSchema(this.db);
         ensureCommandSessionSchema(this.db);
         ensureWorkspaceSchema(this.db);
+        ensureWandTaskSchema(this.db);
+        ensureConnectorSchema(this.db);
         this.ensureDefaultPasswordVault();
     }
     directory() {
@@ -1008,6 +1096,86 @@ export class WandStorage {
         }
         this.db.prepare("DELETE FROM workspace_tasks WHERE id = ?").run(id);
     }
+    listWandTasks(workspaceId) {
+        const rows = this.db.prepare(`SELECT id, identifier, workspace_id, title, description, status, priority, labels_json, due_date, sort_order, 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) => ({
+            id: String(row.id),
+            identifier: typeof row.identifier === "string" && row.identifier ? row.identifier : `TASK-${String(row.id).slice(0, 6)}`,
+            workspaceId: typeof row.workspace_id === "string" ? row.workspace_id : null,
+            title: String(row.title),
+            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",
+            labels: (() => { const parsed = safeJsonParse(String(row.labels_json ?? "[]")); return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : []; })(),
+            dueDate: typeof row.due_date === "string" ? row.due_date : null,
+            sortOrder: Number(row.sort_order) || 0,
+            createdAt: String(row.created_at),
+            updatedAt: String(row.updated_at),
+        }));
+    }
+    getWandTask(id) {
+        return this.listWandTasks().find((task) => task.id === id) ?? null;
+    }
+    createWandTask(input) {
+        const id = crypto.randomUUID();
+        const now = nowIso();
+        const status = input.status ?? "todo";
+        const priority = input.priority ?? "none";
+        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, title, description, status, priority, labels_json, due_date, sort_order, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, identifier, input.workspaceId ?? null, input.title, input.description ?? "", status, priority, JSON.stringify(input.labels ?? []), input.dueDate ?? null, (max?.value ?? -1) + 1, now, now);
+        return this.getWandTask(id);
+    }
+    updateWandTask(id, patch) {
+        const current = this.getWandTask(id);
+        if (!current)
+            return null;
+        const next = { ...current, ...patch, updatedAt: nowIso() };
+        this.db.prepare(`UPDATE wand_tasks SET workspace_id = ?, title = ?, description = ?, status = ?, priority = ?, labels_json = ?, due_date = ?, sort_order = ?, updated_at = ? WHERE id = ?`).run(next.workspaceId, next.title, next.description, next.status, next.priority, JSON.stringify(next.labels), next.dueDate, next.sortOrder, next.updatedAt, id);
+        return next;
+    }
+    deleteWandTask(id) { this.db.prepare("DELETE FROM wand_tasks WHERE id = ?").run(id); }
+    listWandTaskSessionIds(taskId) {
+        const rows = this.db.prepare("SELECT session_id FROM wand_task_sessions WHERE task_id = ? ORDER BY bound_at ASC").all(taskId);
+        return rows.map((row) => row.session_id);
+    }
+    bindWandTaskSession(taskId, sessionId) {
+        if (!this.getWandTask(taskId))
+            throw new Error("未找到该任务。");
+        if (!this.getSession(sessionId))
+            throw new Error("未找到该会话。");
+        this.db.prepare("INSERT OR IGNORE INTO wand_task_sessions (task_id, session_id, bound_at) VALUES (?, ?, ?)").run(taskId, sessionId, nowIso());
+    }
+    unbindWandTaskSession(taskId, sessionId) { this.db.prepare("DELETE FROM wand_task_sessions WHERE task_id = ? AND session_id = ?").run(taskId, sessionId); }
+    bindTaskboardTaskSession(taskId, sessionId) {
+        if (!this.getSession(sessionId))
+            throw new Error("未找到该会话。");
+        this.db.prepare("INSERT OR IGNORE INTO taskboard_session_bindings (task_id, session_id, bound_at) VALUES (?, ?, ?)").run(taskId, sessionId, nowIso());
+    }
+    listTaskboardTaskSessions(taskId) {
+        const rows = this.db.prepare("SELECT session_id FROM taskboard_session_bindings WHERE task_id = ? ORDER BY rowid ASC").all(taskId);
+        return rows.map((row) => row.session_id);
+    }
+    unbindTaskboardTaskSession(taskId, sessionId) {
+        this.db.prepare("DELETE FROM taskboard_session_bindings WHERE task_id = ? AND session_id = ?").run(taskId, sessionId);
+    }
+    listGithubIssueBindings(owner, repo, issueNumber) {
+        const rows = this.db.prepare(`SELECT session_id, bound_at FROM github_issue_bindings
+       WHERE owner = ? AND repo = ? AND issue_number = ? ORDER BY bound_at ASC`).all(owner, repo, issueNumber);
+        return rows.map((row) => ({ sessionId: row.session_id, boundAt: row.bound_at }));
+    }
+    bindGithubIssueSession(owner, repo, issueNumber, sessionId) {
+        if (!this.getSession(sessionId))
+            throw new Error("未找到该会话。");
+        this.db.prepare(`INSERT OR IGNORE INTO github_issue_bindings (owner, repo, issue_number, session_id, bound_at)
+       VALUES (?, ?, ?, ?, ?)`).run(owner, repo, issueNumber, sessionId, nowIso());
+    }
+    unbindGithubIssueSession(owner, repo, issueNumber, sessionId) {
+        this.db.prepare(`DELETE FROM github_issue_bindings WHERE owner = ? AND repo = ? AND issue_number = ? AND session_id = ?`).run(owner, repo, issueNumber, sessionId);
+    }
     listSessionsByWorkspaceTask(taskId) {
         const rows = this.db
             .prepare(`${sessionRowQuery("SELECT")}
@@ -1164,6 +1332,61 @@ export class WandStorage {
             .run(now, id);
         return result.changes > 0;
     }
+    // ============ Connector Methods ============
+    // 第三方服务凭据（GitHub 等）。token 用与密码库同一把 at-rest 密钥加密，
+    // 解密只在服务端发生，绝不通过 /api/settings 回传明文。
+    getConnectorToken(provider) {
+        const row = this.db
+            .prepare("SELECT token FROM connectors WHERE provider = ?")
+            .get(provider);
+        if (!row)
+            return null;
+        const decrypted = decryptVaultSecret(row.token, this.getAppSecret());
+        return decrypted ?? "";
+    }
+    getConnectorMeta(provider) {
+        const row = this.db
+            .prepare("SELECT provider, api_url, username, connected_at, updated_at FROM connectors WHERE provider = ?")
+            .get(provider);
+        if (!row)
+            return null;
+        return {
+            provider: row.provider,
+            apiUrl: row.api_url || null,
+            username: row.username ?? null,
+            connectedAt: row.connected_at ?? null,
+            updatedAt: row.updated_at,
+        };
+    }
+    saveConnector(provider, input) {
+        const now = nowIso();
+        const existing = this.getConnectorMeta(provider);
+        const token = input.token === undefined || input.token === null || input.token === ""
+            ? this.getConnectorToken(provider) ?? ""
+            : input.token;
+        const apiUrl = input.apiUrl === undefined ? (existing?.apiUrl ?? "") : input.apiUrl;
+        const username = input.username === undefined ? (existing?.username ?? null) : input.username;
+        const connectedAt = input.markConnected === false ? (existing?.connectedAt ?? now) : now;
+        const encrypted = this.encryptConnectorToken(token);
+        this.db.prepare(`INSERT INTO connectors (provider, token, api_url, username, connected_at, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(provider) DO UPDATE SET
+         token = excluded.token,
+         api_url = excluded.api_url,
+         username = excluded.username,
+         connected_at = excluded.connected_at,
+         updated_at = excluded.updated_at`).run(provider, encrypted, apiUrl, username, connectedAt, now, now);
+        return { provider, apiUrl: apiUrl || null, username, connectedAt, updatedAt: now };
+    }
+    deleteConnector(provider) {
+        return this.db.prepare("DELETE FROM connectors WHERE provider = ?").run(provider).changes > 0;
+    }
+    encryptConnectorToken(token) {
+        if (!token)
+            return "";
+        const secret = this.getAppSecret();
+        return secret ? encryptVaultSecret(token, secret) : token;
+    }
     // ============ Auth Session Methods ============
     saveAuthSession(token, expiresAt, principal = { kind: "browser-admin", scopes: ["admin"] }) {
         this.db

package/dist/structured-provider-common.js

@@ -116,7 +116,8 @@ export function thinkingEffortToPiLevel(effort) {
         return "low";
     if (effort === "deep")
         return "high";
+    // Pi uses `max`; `xhigh` is a Codex-only level and makes Pi reject the run.
     if (effort === "max")
-        return "xhigh";
+        return "max";
     return effort.startsWith("codex:") ? effort.slice("codex:".length) || null : null;
 }

package/dist/task-types.d.ts

@@ -0,0 +1,19 @@
+export type WandTaskStatus = "todo" | "doing" | "done";
+export type WandTaskPriority = "none" | "low" | "medium" | "high" | "urgent";
+export interface WandTask {
+    id: string;
+    workspaceId: string | null;
+    identifier: string;
+    title: string;
+    description: string;
+    status: WandTaskStatus;
+    priority: WandTaskPriority;
+    labels: string[];
+    dueDate: string | null;
+    sortOrder: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface WandTaskDetail extends WandTask {
+    sessionIds: string[];
+}

package/dist/task-types.js

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

package/dist/taskboard-bridge.d.ts

@@ -0,0 +1,11 @@
+import type { RequestHandler } from "express";
+import type { WandStorage } from "./storage.js";
+import type { SessionRegistry } from "./session-registry.js";
+import type { StructuredSessionManager } from "./structured-session-manager.js";
+interface TaskboardBridge {
+    handler: RequestHandler;
+    close(): Promise<void>;
+}
+export declare function taskboardIntegrationScript(): string;
+export declare function startTaskboardBridge(configDir: string, storage?: WandStorage, sessions?: SessionRegistry, structured?: StructuredSessionManager, fallbackCwd?: string): Promise<TaskboardBridge>;
+export {};