@co0ontty/wand 4.106.0 → 4.106.1

package/dist/storage/knowledge-repository.js

@@ -1,12 +1,14 @@
 import crypto from "node:crypto";
+import { formatGlobalKnowledge, isGlobalKnowledgeInstallation, readGlobalKnowledgeSync, syncGlobalKnowledgeFiles } from "../global-knowledge.js";
 import { isGlobalWorkspace } from "../workspace-binding.js";
 import { normalizeEmployeeKnowledge } from "../employee-knowledge-content.js";
 import { EMPLOYEE_KNOWLEDGE_MAX_ENTRIES } from "../employee-knowledge-types.js";
-import { KnowledgeError } from "../knowledge-types.js";
+import { GLOBAL_KNOWLEDGE_MAX_BYTES, GLOBAL_KNOWLEDGE_OWNER_ID, KnowledgeError } from "../knowledge-types.js";
 const hash = (value) => crypto.createHash("sha256").update(value).digest("hex");
-const spec = (scope) => scope === "personal"
-    ? { table: "employee_knowledge", owner: "employee_id" }
-    : { table: "project_knowledge", owner: "workspace_id" };
+const spec = (scope) => scope === "global"
+    ? { table: "global_knowledge", owner: "owner_id" }
+    : scope === "personal" ? { table: "employee_knowledge", owner: "employee_id" }
+        : { table: "project_knowledge", owner: "workspace_id" };
 export class KnowledgeRepository {
     db;
     s;
@@ -15,6 +17,11 @@ export class KnowledgeRepository {
         this.s = s;
     }
     #owner(scope, ownerId) {
+        if (scope === "global") {
+            if (ownerId !== GLOBAL_KNOWLEDGE_OWNER_ID)
+                throw new KnowledgeError("全局知识库归属无效。", 400);
+            return { name: "全局知识库", readOnly: false };
+        }
         if (scope === "personal") {
             const employee = this.s.getSiliconEmployeeDefinition(ownerId);
             if (!employee)
@@ -38,7 +45,8 @@ export class KnowledgeRepository {
       WHERE NOT EXISTS (SELECT 1 FROM workspaces w WHERE w.id = workspace_id) GROUP BY workspace_id`).all();
         for (const row of orphans)
             projects.push({ id: String(row.workspace_id), name: `${String(row.project_name)}（已移除项目）`, readOnly: true });
-        return { employees: this.s.listSiliconEmployees({ includeArchived: true }).map(employee => ({ id: employee.id, name: employee.name })), projects };
+        return { global: { id: GLOBAL_KNOWLEDGE_OWNER_ID, name: "全局知识库" },
+            employees: this.s.listSiliconEmployees({ includeArchived: true }).map(employee => ({ id: employee.id, name: employee.name })), projects };
     }
     #project(row, scope, ownerId) {
         return { id: row.id, scope, ownerId, title: row.title || row.content.split(/\r?\n/).find(line => line.trim())?.trim().slice(0, 100) || "无标题文档",
@@ -54,7 +62,10 @@ export class KnowledgeRepository {
         const normalizedQuery = query.trim().slice(0, 200).toLocaleLowerCase();
         const entries = rows.map(row => this.#project(row, scope, ownerId))
             .filter(entry => `${entry.title}\n${entry.content}\n${entry.folder}`.toLocaleLowerCase().includes(normalizedQuery));
-        return { scope, ownerId, ownerName: owner.name, readOnly: owner.readOnly, entries, total: rows.length, limit: EMPLOYEE_KNOWLEDGE_MAX_ENTRIES };
+        return { scope, ownerId, ownerName: owner.name, readOnly: owner.readOnly, entries, total: rows.length, limit: EMPLOYEE_KNOWLEDGE_MAX_ENTRIES,
+            ...(scope === "global" ? { totalBytes: Buffer.byteLength(formatGlobalKnowledge(rows.map(row => this.#project(row, scope, ownerId)))),
+                maxTotalBytes: GLOBAL_KNOWLEDGE_MAX_BYTES,
+                ...(isGlobalKnowledgeInstallation(this.s.databasePath()) ? { cliSync: this.s.getPreference("pref:globalKnowledgeSync", readGlobalKnowledgeSync()) } : {}) } : {}) };
     }
     getKnowledgeDocument(scope, ownerId, id, accessToken) {
         if (accessToken)
@@ -90,9 +101,42 @@ export class KnowledgeRepository {
             }
         return { content, title, folder };
     }
+    #checkGlobalBudget(scope, input, replacingId = "") {
+        if (scope !== "global")
+            return;
+        const entries = this.readKnowledgeLibrary("global", GLOBAL_KNOWLEDGE_OWNER_ID).entries.filter(entry => entry.id !== replacingId);
+        const next = { ...input, title: input.title || input.content.split(/\r?\n/).find(line => line.trim())?.trim().slice(0, 100) || "无标题文档",
+            folder: input.folder || "未分类", id: replacingId || `gk_${"0".repeat(32)}`, revision: 9999999999 };
+        const total = Buffer.byteLength(formatGlobalKnowledge([...entries, next]));
+        if (total > GLOBAL_KNOWLEDGE_MAX_BYTES)
+            throw new KnowledgeError("全局约定每轮完整加载，合计最多 24 KB（含标题与目录）。请精简后保存；已有内容不会被截断或删除。");
+    }
+    syncGlobalKnowledge() {
+        if (!isGlobalKnowledgeInstallation(this.s.databasePath()))
+            return;
+        try {
+            // Serialize snapshots and file writes with other CLI processes using the same database.
+            this.s.transaction(() => {
+                const library = this.readKnowledgeLibrary("global", GLOBAL_KNOWLEDGE_OWNER_ID);
+                // Do not create rule files until a global library has been used at least once.
+                if (!library.total && !readGlobalKnowledgeSync().length)
+                    return;
+                const results = syncGlobalKnowledgeFiles(formatGlobalKnowledge(library.entries));
+                this.s.setPreference("pref:globalKnowledgeSync", results);
+                for (const result of results)
+                    if (result.error)
+                        console.warn(`[knowledge] ${result.provider}: ${result.error}`);
+            });
+        }
+        catch (error) {
+            const message = error.message;
+            this.s.setPreference("pref:globalKnowledgeSync", [{ provider: "全部 CLI", path: "", error: message }]);
+            console.warn(`[knowledge] CLI 同步未完成：${message}`);
+        }
+    }
     createKnowledgeDocument(scope, ownerId, input, accessToken) {
         const values = this.#normalize(input);
-        return this.s.transaction(() => {
+        const result = this.s.transaction(() => {
             if (accessToken)
                 this.#requireAccess(accessToken, scope, ownerId);
             const owner = this.#owner(scope, ownerId);
@@ -106,9 +150,13 @@ export class KnowledgeRepository {
             const count = Number(this.db.prepare(`SELECT COUNT(*) AS count FROM ${table} WHERE ${column} = ?`).get(ownerId)?.count ?? 0);
             if (count >= EMPLOYEE_KNOWLEDGE_MAX_ENTRIES)
                 throw new KnowledgeError("知识库已满，请先删除不需要的文档；不会自动丢弃旧知识。");
-            const id = `${scope === "personal" ? "k" : "pk"}_${crypto.randomUUID().replace(/-/g, "")}`;
+            this.#checkGlobalBudget(scope, values);
+            const id = `${scope === "global" ? "gk" : scope === "personal" ? "k" : "pk"}_${crypto.randomUUID().replace(/-/g, "")}`;
             const now = new Date().toISOString();
-            if (scope === "personal")
+            if (scope === "global")
+                this.db.prepare(`INSERT INTO global_knowledge (id, owner_id, title, folder, content, content_hash, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(id, ownerId, values.title, values.folder, values.content, contentHash, now, now);
+            else if (scope === "personal")
                 this.db.prepare(`INSERT INTO employee_knowledge (id, employee_id, title, folder, content, content_hash, created_at, updated_at)
         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(id, ownerId, values.title, values.folder, values.content, contentHash, now, now);
             else
@@ -116,10 +164,13 @@ export class KnowledgeRepository {
         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, ownerId, owner.name, values.title, values.folder, values.content, contentHash, now, now);
             return { entry: this.getKnowledgeDocument(scope, ownerId, id), created: true };
         });
+        if (scope === "global")
+            this.syncGlobalKnowledge();
+        return result;
     }
     updateKnowledgeDocument(scope, ownerId, id, revision, input, accessToken) {
         const values = this.#normalize(input);
-        return this.s.transaction(() => {
+        const result = this.s.transaction(() => {
             if (accessToken)
                 this.#requireAccess(accessToken, scope, ownerId);
             const owner = this.#owner(scope, ownerId);
@@ -133,12 +184,16 @@ export class KnowledgeRepository {
             const duplicate = this.db.prepare(`SELECT id FROM ${table} WHERE ${column} = ? AND content_hash = ? AND id != ?`).get(ownerId, contentHash, id);
             if (duplicate)
                 throw new KnowledgeError("当前知识库已有相同正文，请核对后保留一篇。");
+            this.#checkGlobalBudget(scope, values, id);
             this.db.prepare(`UPDATE ${table} SET title = ?, folder = ?, content = ?, content_hash = ?, updated_at = ?, revision = revision + 1
         WHERE ${column} = ? AND id = ? AND revision = ?`).run(values.title, values.folder, values.content, contentHash, new Date().toISOString(), ownerId, id, revision);
             // An older execution must not recreate the previous fact after the user corrected it.
             this.invalidateKnowledgeNamespace(scope, ownerId);
             return this.getKnowledgeDocument(scope, ownerId, id);
         });
+        if (scope === "global")
+            this.syncGlobalKnowledge();
+        return result;
     }
     deleteKnowledgeDocument(scope, ownerId, id, revision, accessToken) {
         this.s.transaction(() => {
@@ -151,6 +206,8 @@ export class KnowledgeRepository {
             this.db.prepare(`DELETE FROM ${table} WHERE ${owner} = ? AND id = ?`).run(ownerId, id);
             this.invalidateKnowledgeNamespace(scope, ownerId);
         });
+        if (scope === "global")
+            this.syncGlobalKnowledge();
     }
     invalidateKnowledgeNamespace(scope, ownerId) {
         this.db.prepare(`INSERT INTO knowledge_namespace_versions(scope, owner_id, revision) VALUES (?, ?, 1)
@@ -173,16 +230,16 @@ export class KnowledgeRepository {
         const task = binding?.workspaceTaskId ? this.s.getWorkspaceTask(binding.workspaceTaskId) : null;
         const workspace = binding?.workspaceId ? this.s.getWorkspace(binding.workspaceId) : null;
         const workspaceId = workspace && !isGlobalWorkspace(workspace) && (!binding?.workspaceTaskId || task?.workspaceId === workspace.id) ? workspace.id : null;
-        return employeeId || workspaceId ? { sessionId, employeeId, workspaceId } : null;
+        return { sessionId, employeeId, workspaceId };
     }
     issueKnowledgeAccess(sessionId, now = Date.now()) {
         const scope = this.knowledgeSessionScope(sessionId);
         if (!scope)
-            throw new KnowledgeError("当前会话未绑定可用员工或项目，知识库能力不可用。", 403);
+            throw new KnowledgeError("当前会话不存在或不允许访问知识库。", 403);
         this.db.prepare("DELETE FROM knowledge_access WHERE expires_at <= ?").run(now);
         const token = crypto.randomBytes(32).toString("base64url");
-        this.db.prepare(`INSERT INTO knowledge_access (token_hash, session_id, employee_id, workspace_id, employee_revision, project_revision, expires_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?)`).run(hash(token), sessionId, scope.employeeId, scope.workspaceId, this.#namespaceRevision("personal", scope.employeeId), this.#namespaceRevision("project", scope.workspaceId), now + 6 * 3600_000);
+        this.db.prepare(`INSERT INTO knowledge_access (token_hash, session_id, employee_id, workspace_id, employee_revision, project_revision, global_revision, expires_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(hash(token), sessionId, scope.employeeId, scope.workspaceId, this.#namespaceRevision("personal", scope.employeeId), this.#namespaceRevision("project", scope.workspaceId), this.#namespaceRevision("global", GLOBAL_KNOWLEDGE_OWNER_ID), now + 6 * 3600_000);
         return token;
     }
     resolveKnowledgeAccess(token, now = Date.now()) {
@@ -194,7 +251,8 @@ export class KnowledgeRepository {
         const current = this.knowledgeSessionScope(String(row.session_id));
         if (!current || current.employeeId !== row.employee_id || current.workspaceId !== row.workspace_id
             || this.#namespaceRevision("personal", current.employeeId) !== row.employee_revision
-            || this.#namespaceRevision("project", current.workspaceId) !== row.project_revision)
+            || this.#namespaceRevision("project", current.workspaceId) !== row.project_revision
+            || this.#namespaceRevision("global", GLOBAL_KNOWLEDGE_OWNER_ID) !== row.global_revision)
             return null;
         return current;
     }
@@ -202,7 +260,8 @@ export class KnowledgeRepository {
     revokeSessionKnowledgeAccess(sessionId) { this.db.prepare("DELETE FROM knowledge_access WHERE session_id = ?").run(sessionId); }
     #requireAccess(token, scope, ownerId) {
         const access = this.resolveKnowledgeAccess(token);
-        if ((scope === "personal" ? access?.employeeId : access?.workspaceId) !== ownerId)
+        if (!access || (scope === "global" ? GLOBAL_KNOWLEDGE_OWNER_ID : scope === "personal" ? access.employeeId : access.workspaceId) !== ownerId) {
             throw new KnowledgeError("知识库归属已变化或访问已失效，请等待新的会话执行。", 403);
+        }
     }
 }

package/dist/storage/mappers.d.ts

@@ -128,6 +128,7 @@ export interface WorkspaceRow {
 export declare function mapWorkspaceKind(raw: string | null | undefined): WorkspaceKind;
 export declare function mapWorkspaceRow(row: WorkspaceRow): Workspace;
 export interface WorkspaceTaskRow {
+    container_kind?: string;
     id: string;
     workspace_id: string;
     name: string;

package/dist/storage/mappers.js

@@ -196,7 +196,11 @@ export function parseSessionOptions(raw) {
         options.queuedInputScheduling = parsed.queuedInputScheduling.map(value => isRecord(value) && (value.source === "user" || value.source === "task")
             && typeof value.enqueuedAt === "string" && Number.isFinite(Date.parse(value.enqueuedAt))
             ? { source: value.source, enqueuedAt: value.enqueuedAt,
-                ...(Number.isSafeInteger(value.sequence) && Number(value.sequence) >= 0 ? { sequence: Number(value.sequence) } : {}) }
+                ...(Number.isSafeInteger(value.sequence) && Number(value.sequence) >= 0 ? { sequence: Number(value.sequence) } : {}),
+                ...(isRecord(value.handoff) && typeof value.handoff.id === "string"
+                    && typeof value.handoff.boundaryId === "string" && typeof value.handoff.incarnationId === "string"
+                    ? { handoff: { id: value.handoff.id, boundaryId: value.handoff.boundaryId, incarnationId: value.handoff.incarnationId } } : {}),
+                ...(typeof value.acceptanceId === "string" ? { acceptanceId: value.acceptanceId } : {}) }
             : { source: "task", enqueuedAt: new Date(0).toISOString() });
     }
     if (isAutonomyPolicy(parsed.autonomyPolicy))
@@ -383,6 +387,7 @@ export function mapWorkspaceTaskRow(row) {
         id: row.id,
         workspaceId: row.workspace_id,
         name: row.name,
+        kind: row.container_kind === "section" ? "section" : "task",
         worktree: mapWorkspaceTaskWorktree(row.worktree_json),
         ...(cwd ? { cwd } : {}),
         milestoneId: typeof row.milestone_id === "string" && row.milestone_id ? row.milestone_id : null,

package/dist/storage/migrations.js

@@ -403,4 +403,64 @@ export const STORAGE_MIGRATIONS = [
                 db.exec("ALTER TABLE wand_tasks ADD COLUMN retention_archive_version INTEGER");
             }
         } },
+    { version: 24, name: "task-two-level-workflow", up: db => {
+            const columns = new Set(db.prepare("PRAGMA table_info(wand_tasks)").all().map(column => column.name));
+            if (!columns.has("verification_json"))
+                db.exec("ALTER TABLE wand_tasks ADD COLUMN verification_json TEXT");
+            if (!columns.has("delivery_revision"))
+                db.exec("ALTER TABLE wand_tasks ADD COLUMN delivery_revision INTEGER NOT NULL DEFAULT 0");
+            const dispatchColumns = new Set(db.prepare("PRAGMA table_info(wand_task_comment_dispatches)").all().map(column => column.name));
+            if (!dispatchColumns.has("purpose"))
+                db.exec("ALTER TABLE wand_task_comment_dispatches ADD COLUMN purpose TEXT NOT NULL DEFAULT 'execution'");
+            if (!dispatchColumns.has("review_revision"))
+                db.exec("ALTER TABLE wand_task_comment_dispatches ADD COLUMN review_revision INTEGER");
+            db.exec(`
+      CREATE TABLE IF NOT EXISTS task_workflow_events (
+        id TEXT PRIMARY KEY, task_id TEXT NOT NULL REFERENCES wand_tasks(id) ON DELETE CASCADE,
+        request_id TEXT NOT NULL, signature TEXT NOT NULL, action TEXT NOT NULL,
+        actor_kind TEXT NOT NULL, actor_id TEXT, source_session_id TEXT,
+        evidence TEXT NOT NULL, blocker TEXT NOT NULL, created_at TEXT NOT NULL, result_json TEXT NOT NULL,
+        UNIQUE(task_id, request_id)
+      );
+      CREATE INDEX IF NOT EXISTS idx_task_workflow_history ON task_workflow_events(task_id, created_at);
+      CREATE TABLE IF NOT EXISTS task_workflow_access (
+        token_hash TEXT PRIMARY KEY, task_id TEXT NOT NULL REFERENCES wand_tasks(id) ON DELETE CASCADE,
+        session_id TEXT NOT NULL REFERENCES command_sessions(id) ON DELETE CASCADE,
+        employee_id TEXT, workspace_task_id TEXT NOT NULL, delivery_revision INTEGER NOT NULL, expires_at INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_task_workflow_access_session ON task_workflow_access(session_id);
+      CREATE TRIGGER IF NOT EXISTS revoke_task_workflow_access_on_binding
+      AFTER UPDATE OF workspace_id, workspace_task_id, session_options, automation_id ON command_sessions
+      WHEN OLD.workspace_id IS NOT NEW.workspace_id OR OLD.workspace_task_id IS NOT NEW.workspace_task_id
+        OR OLD.automation_id IS NOT NEW.automation_id
+        OR (CASE WHEN json_valid(OLD.session_options) THEN json_extract(OLD.session_options, '$.employeeId') END)
+          IS NOT (CASE WHEN json_valid(NEW.session_options) THEN json_extract(NEW.session_options, '$.employeeId') END)
+      BEGIN DELETE FROM task_workflow_access WHERE session_id = NEW.id; END;
+    `);
+        } },
+    { version: 25, name: "structured-input-acceptances", up: db => db.exec(`
+    CREATE TABLE IF NOT EXISTS structured_input_acceptances (
+      session_id TEXT NOT NULL REFERENCES command_sessions(id) ON DELETE CASCADE,
+      idempotency_key TEXT NOT NULL, signature TEXT NOT NULL, receipt_json TEXT NOT NULL,
+      PRIMARY KEY(session_id, idempotency_key)
+    );
+    CREATE TRIGGER IF NOT EXISTS delete_structured_input_acceptances
+      AFTER DELETE ON command_sessions BEGIN
+        DELETE FROM structured_input_acceptances WHERE session_id = OLD.id;
+      END;
+  `) },
+    { version: 26, name: "global-knowledge", up: db => {
+            db.exec(`CREATE TABLE IF NOT EXISTS global_knowledge (
+      id TEXT PRIMARY KEY, owner_id TEXT NOT NULL CHECK(owner_id = 'global'),
+      title TEXT NOT NULL DEFAULT '', folder TEXT NOT NULL DEFAULT '', content TEXT NOT NULL,
+      content_hash TEXT NOT NULL, revision INTEGER NOT NULL DEFAULT 1,
+      created_at TEXT NOT NULL, updated_at TEXT, UNIQUE(owner_id, content_hash)
+    )`);
+            const columns = db.prepare("PRAGMA table_info(knowledge_access)").all();
+            if (!columns.some(column => column.name === "global_revision")) {
+                // Existing grants predate global access and must not silently acquire it.
+                db.exec("ALTER TABLE knowledge_access ADD COLUMN global_revision INTEGER NOT NULL DEFAULT -1");
+            }
+        } },
+    { version: 27, name: "workspace-session-sections", up: db => db.exec("ALTER TABLE workspace_tasks ADD COLUMN container_kind TEXT NOT NULL DEFAULT 'task'") },
 ];

package/dist/storage/session-input-repository.d.ts

@@ -0,0 +1,19 @@
+import type { DatabaseSync } from "node:sqlite";
+import type { WandStorage } from "../storage.js";
+import type { SessionSnapshot } from "../types.js";
+/** Acceptance proves durable ownership of the input, not external tool execution. */
+export interface StructuredInputReceipt {
+    accepted: true;
+    acceptanceId: string;
+    sessionId: string;
+    idempotencyKey: string;
+    acceptedAt: string;
+}
+export declare class SessionInputRepository {
+    private readonly db;
+    private readonly s;
+    constructor(db: DatabaseSync, s: WandStorage);
+    getStructuredInputReceipt(sessionId: string, key: string, signature: string): StructuredInputReceipt | null;
+    /** Queue/user turn and receipt share the write lock and commit/rollback boundary. */
+    acceptStructuredInput(snapshot: SessionSnapshot, signature: string, receipt: StructuredInputReceipt, userTurn?: boolean): boolean;
+}

package/dist/storage/session-input-repository.js

@@ -0,0 +1,35 @@
+export class SessionInputRepository {
+    db;
+    s;
+    constructor(db, s) {
+        this.db = db;
+        this.s = s;
+    }
+    getStructuredInputReceipt(sessionId, key, signature) {
+        const row = this.db.prepare(`SELECT signature, receipt_json FROM structured_input_acceptances
+      WHERE session_id = ? AND idempotency_key = ?`).get(sessionId, key);
+        if (!row)
+            return null;
+        if (row.signature !== signature) {
+            throw Object.assign(new Error("该幂等键已用于不同的消息或操作，请核对原请求。"), { code: "idempotency_key_conflict" });
+        }
+        return JSON.parse(row.receipt_json);
+    }
+    /** Queue/user turn and receipt share the write lock and commit/rollback boundary. */
+    acceptStructuredInput(snapshot, signature, receipt, userTurn = false) {
+        return this.s.transaction(() => {
+            if (this.getStructuredInputReceipt(snapshot.id, receipt.idempotencyKey, signature))
+                return false;
+            const exists = this.db.prepare("SELECT 1 FROM command_sessions WHERE id = ? AND session_kind = 'structured'").get(snapshot.id);
+            if (!exists)
+                throw new Error("未找到该结构化会话。");
+            this.s.updateSessionRuntimeMetadata(snapshot);
+            if (userTurn)
+                this.s.checkpointSessionMessages(snapshot.id, snapshot.messages ?? [], snapshot.structuredState);
+            this.db.prepare(`INSERT INTO structured_input_acceptances
+        (session_id, idempotency_key, signature, receipt_json) VALUES (?, ?, ?, ?)`)
+                .run(snapshot.id, receipt.idempotencyKey, signature, JSON.stringify(receipt));
+            return true;
+        });
+    }
+}

package/dist/storage/task-workflow-repository.d.ts

@@ -0,0 +1,29 @@
+import type { DatabaseSync } from "node:sqlite";
+import type { WandStorage } from "../storage.js";
+import type { SessionRegistry } from "../session-registry.js";
+import { type TaskWorkflowActor } from "../task-workflow.js";
+import { type WandTask } from "../task-types.js";
+type Grant = {
+    taskId: string;
+    sessionId: string;
+    employeeId: string | null;
+    revision: number;
+};
+export declare class TaskWorkflowRepository {
+    private readonly db;
+    private readonly s;
+    constructor(db: DatabaseSync, s: WandStorage);
+    /** Called only by an active runner; never grants the project or arbitrary task IDs. */
+    issueTaskWorkflowAccess(sessionId: string): {
+        token: string;
+        taskId: string;
+        revision: number;
+    } | null;
+    resolveTaskWorkflowAccess(token: string): Grant | null;
+    revokeTaskWorkflowAccess(token: string): void;
+    applyEmployeeTaskWorkflow(token: string, taskId: string, input: unknown): WandTask;
+    applyTaskWorkflow(taskId: string, value: unknown, actor: TaskWorkflowActor, registry?: SessionRegistry): WandTask;
+    hasTaskReviewReceipt(taskId: string, sessionId: string, revision: number): boolean;
+    listTaskWorkflowEvents(taskId: string): Array<Record<string, unknown>>;
+}
+export {};

package/dist/storage/task-workflow-repository.js

@@ -0,0 +1,110 @@
+import crypto from "node:crypto";
+import { HttpError } from "../http-error.js";
+import { isArchiveBlocked } from "../archive-policy.js";
+import { AI_TEAM_ACTIVE_RUN_STATUSES } from "../ai-team-types.js";
+import { parseTaskWorkflowInput, taskWorkflowPatch } from "../task-workflow.js";
+const hash = (value) => crypto.createHash("sha256").update(value).digest("hex");
+export class TaskWorkflowRepository {
+    db;
+    s;
+    constructor(db, s) {
+        this.db = db;
+        this.s = s;
+    }
+    /** Called only by an active runner; never grants the project or arbitrary task IDs. */
+    issueTaskWorkflowAccess(sessionId) {
+        const session = this.s.getSessionSlim(sessionId);
+        const scope = this.s.knowledgeSessionScope(sessionId);
+        if (!session || session.archived || ["failed", "stopped", "exited"].includes(session.status) || !session.workspaceTaskId || !scope?.employeeId || session.automationId?.startsWith("dingtalk:"))
+            return null;
+        const employee = this.s.getSiliconEmployeeDefinition(scope.employeeId);
+        if (!employee || employee.archivedAt)
+            return null;
+        const task = this.s.getWandTaskByWorkspaceTaskId(session.workspaceTaskId);
+        if (!task || task.status === "archived" || task.workspaceId !== scope.workspaceId)
+            return null;
+        const token = crypto.randomBytes(32).toString("base64url"), revision = task.deliveryRevision ?? 0;
+        this.db.prepare("DELETE FROM task_workflow_access WHERE expires_at <= ? OR session_id = ?").run(Date.now(), sessionId);
+        this.db.prepare(`INSERT INTO task_workflow_access(token_hash, task_id, session_id, employee_id, workspace_task_id, delivery_revision, expires_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?)`).run(hash(token), task.id, sessionId, scope.employeeId, session.workspaceTaskId, revision, Date.now() + 6 * 3600_000);
+        return { token, taskId: task.id, revision };
+    }
+    resolveTaskWorkflowAccess(token) {
+        if (!/^[A-Za-z0-9_-]{43}$/.test(token))
+            return null;
+        const row = this.db.prepare("SELECT * FROM task_workflow_access WHERE token_hash = ? AND expires_at > ?").get(hash(token), Date.now());
+        if (!row)
+            return null;
+        const session = this.s.getSessionSlim(String(row.session_id));
+        const scope = this.s.knowledgeSessionScope(String(row.session_id));
+        const task = this.s.getWandTask(String(row.task_id));
+        const employee = scope?.employeeId ? this.s.getSiliconEmployeeDefinition(scope.employeeId) : null;
+        if (!employee || employee.archivedAt)
+            return null;
+        if (!session || session.archived || ["failed", "stopped", "exited"].includes(session.status) || !scope || !task || task.status === "archived" || task.workspaceTaskId !== row.workspace_task_id
+            || session.workspaceTaskId !== row.workspace_task_id || scope.employeeId !== row.employee_id || scope.workspaceId !== task.workspaceId
+            || (task.deliveryRevision ?? 0) !== row.delivery_revision)
+            return null;
+        return { taskId: task.id, sessionId: session.id, employeeId: scope.employeeId, revision: Number(row.delivery_revision) };
+    }
+    revokeTaskWorkflowAccess(token) { this.db.prepare("DELETE FROM task_workflow_access WHERE token_hash = ?").run(hash(token)); }
+    applyEmployeeTaskWorkflow(token, taskId, input) {
+        return this.s.transaction(() => {
+            const access = this.resolveTaskWorkflowAccess(token);
+            if (!access || access.taskId !== taskId)
+                throw new HttpError(403, "forbidden", "任务回填权限已失效或不属于当前任务，请等待新的执行；不能改用所有者身份。");
+            return this.applyTaskWorkflow(taskId, input, { kind: "employee", sessionId: access.sessionId, employeeId: access.employeeId });
+        });
+    }
+    applyTaskWorkflow(taskId, value, actor, registry) {
+        const input = parseTaskWorkflowInput(value);
+        const signature = hash(JSON.stringify({ actor, input }));
+        return this.s.transaction(() => {
+            const previous = this.db.prepare("SELECT signature, result_json FROM task_workflow_events WHERE task_id = ? AND request_id = ?").get(taskId, input.requestId);
+            if (previous) {
+                if (previous.signature !== signature)
+                    throw new HttpError(409, "conflict", "请求标识已用于另一份验收意图，请保留原输入并核对记录。");
+                return this.s.getWandTask(taskId) ?? JSON.parse(String(previous.result_json));
+            }
+            const task = this.s.getWandTask(taskId);
+            if (!task)
+                throw new HttpError(404, "not_found", "任务已删除。");
+            if (task.updatedAt !== input.expectedUpdatedAt)
+                throw new HttpError(409, "conflict", "任务已变化，请刷新并核对当前交付后再操作；草稿不会自动重发。");
+            const children = this.s.listWandTaskChildren(taskId);
+            const ownedSession = actor.kind === "employee" ? actor.sessionId : null;
+            const family = [task, ...children];
+            for (const member of family) {
+                const queued = this.s.countQueuedTaskCommentDispatchesForTask(member.id);
+                if (queued > 0)
+                    throw new HttpError(409, "busy", "任务仍有排队执行，请先处理队列。");
+                for (const id of this.s.listWandTaskSessionIds(member.id)) {
+                    if (id === ownedSession)
+                        continue;
+                    const session = registry?.getSlim(id) ?? this.s.getSessionSlim(id);
+                    if (session && isArchiveBlocked(session))
+                        throw new HttpError(409, "busy", "任务仍有执行或等待处理的请求，不能推进验收。");
+                }
+                if ([member.id, member.workspaceTaskId].some(id => id && this.s.listAiTeamRuns({ taskId: id, statuses: AI_TEAM_ACTIVE_RUN_STATUSES, limit: 1 }).length))
+                    throw new HttpError(409, "busy", "任务仍有运行中的团队，不能推进验收。");
+            }
+            const now = new Date(Math.max(Date.now(), Date.parse(task.updatedAt) + 1)).toISOString();
+            const patch = taskWorkflowPatch(task, children, input, actor, now);
+            const result = this.s.tasks.writeWandTask(task, patch, true);
+            const id = crypto.randomUUID();
+            this.db.prepare(`INSERT INTO task_workflow_events(id, task_id, request_id, signature, action, actor_kind, actor_id, source_session_id, evidence, blocker, created_at, result_json)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, taskId, input.requestId, signature, input.action, actor.kind, actor.kind === "employee" ? actor.employeeId : null, ownedSession, input.evidence, input.blocker, now, JSON.stringify(result));
+            const labels = { submit: "交付已提交，等待 AI 验收", pass: "AI 验收通过，等待人工确认归档", fail: "AI 验收未通过，退回执行中", return: "人工退回，继续修改", accept: "人工确认交付并归档" };
+            this.db.prepare("INSERT INTO wand_task_comments(id, task_id, author_name, body, created_at) VALUES (?, ?, ?, ?, ?)")
+                .run(id, taskId, "验收流程", [labels[input.action], input.evidence ? `证据：${input.evidence}` : "", input.blocker ? `缺口：${input.blocker}` : "", `交付版本：${result.deliveryRevision ?? 0}${ownedSession ? ` · 来源会话：${ownedSession}` : ""}`].filter(Boolean).join("\n\n"), now);
+            return result;
+        });
+    }
+    hasTaskReviewReceipt(taskId, sessionId, revision) {
+        return Boolean(this.db.prepare("SELECT 1 FROM task_workflow_events WHERE task_id = ? AND source_session_id = ? AND action IN ('pass', 'fail') AND json_extract(result_json, '$.verification.revision') = ? LIMIT 1").get(taskId, sessionId, revision));
+    }
+    listTaskWorkflowEvents(taskId) {
+        return this.db.prepare(`SELECT id, request_id AS requestId, action, actor_kind AS actorKind, actor_id AS actorId,
+      source_session_id AS sourceSessionId, evidence, blocker, created_at AS createdAt FROM task_workflow_events WHERE task_id = ? ORDER BY created_at DESC, rowid DESC LIMIT 50`).all(taskId);
+    }
+}

package/dist/storage/tasks-repository.d.ts

@@ -39,6 +39,7 @@ export declare class TaskRepository {
     countWandTaskComments(taskId: string): number;
     /** One grouped query for task-list projections; tasks without comments are omitted (read as zero). */
     countWandTaskCommentsByTask(): Map<string, number>;
+    isTaskReviewComment(id: string): boolean;
     getWandTaskComment(id: string): WandTaskComment | null;
     /** One task-scoped query for a bounded set of known comment IDs (e.g. status refresh for older pages). */
     getWandTaskCommentsByIds(taskId: string, ids: readonly string[]): WandTaskComment[];
@@ -61,6 +62,8 @@ export declare class TaskRepository {
         referencedTaskIds?: readonly string[];
         agent?: WandTaskAgent | null;
         queued?: boolean;
+        purpose?: "execution" | "review";
+        reviewRevision?: number | null;
     }): WandTaskComment;
     updateTaskCommentDispatch(id: string, state: "queued" | "pending" | "accepted" | "failed" | "unknown", sessionId: string | null, error?: string | null): void;
     /** Hold only unclaimed intents atomically. Running/pending deliveries are never touched. */
@@ -117,8 +120,10 @@ export declare class TaskRepository {
     private insertWandTaskBody;
     createWandTask(input: CreateWandTaskInput): WandTask;
     /** Private canonical writer; callers own the transaction, never a reverse writer. */
-    writeWandTask(current: WandTask, patch: WandTaskPatch): WandTask;
+    writeWandTask(current: WandTask, patch: WandTaskPatch, workflow?: boolean): WandTask;
     updateWandTask(id: string, patch: WandTaskPatch): WandTask | null;
+    /** Explicit destructive project removal collects history, never claims delivery acceptance. */
+    archiveTaskForWorkspaceRemoval(id: string): WandTask | null;
     /** Commit completion archives only the selected completed cards, atomically. */
     archiveCompletedWandTasks(ids: readonly string[]): string[];
     /**