@imenam/mcp-organizer 0.0.0-stage → 1.0.2

package/dist/src/core/store.js

@@ -0,0 +1,2119 @@
+import { openDatabase } from "./db.js";
+import { ForbiddenError, InvariantError, NotFoundError, OrganizerError } from "./errors.js";
+import { positionBetween } from "../../shared/logic/positions.js";
+import { newId } from "./ids.js";
+import { WatcherRegistry } from "./watchers.js";
+import { MAX_TASK_DEPTH, } from "../../shared/schemas/enums.schema.js";
+import { AccessLinkSchema, AgentActionSchema, AgentTokenSchema, AgentRequestSchema, AttachmentSchema, ChangeSchema, ChecklistItemSchema, CommentSchema, EntityVersionSchema, IdeaSchema, IdeaSnapshotSchema, InvitationSchema, MembershipSchema, NotificationSchema, SessionSchema, SpaceSchema, TagSchema, TaskSchema, TaskSnapshotSchema, TestCheckpointSchema, TestResultSchema, TestReviewSchema, UserSchema, UserSettingsSchema, } from "../../shared/schemas/entities.schema.js";
+/** Valide `value` avec `schema` ; une donnée invalide est une erreur métier qui liste les champs fautifs. */
+function validate(schema, value, what) {
+    const parsed = schema.safeParse(value);
+    if (!parsed.success) {
+        const issues = parsed.error.issues.map((issue) => `${issue.path.map(String).join(".") || "(root)"} ${issue.message}`);
+        throw new OrganizerError(`Invalid ${what}: ${issues.join("; ")}.`);
+    }
+    return parsed.data;
+}
+function bool(value) {
+    return value === 1;
+}
+function userFromRow(row) {
+    return UserSchema.parse({
+        id: row.id,
+        email: row.email,
+        displayName: row.display_name,
+        passwordHash: row.password_hash,
+        status: row.status,
+        createdAt: row.created_at,
+    });
+}
+function settingsFromRow(row) {
+    return UserSettingsSchema.parse({
+        userId: row.user_id,
+        notifyAssignApp: bool(row.notify_assign_app),
+        notifyAssignEmail: bool(row.notify_assign_email),
+        notifyCommentApp: bool(row.notify_comment_app),
+        notifyCommentEmail: bool(row.notify_comment_email),
+    });
+}
+function sessionFromRow(row) {
+    return SessionSchema.parse({ idHash: row.id_hash, userId: row.user_id, createdAt: row.created_at, expiresAt: row.expires_at });
+}
+function accessLinkFromRow(row) {
+    return AccessLinkSchema.parse({
+        id: row.id,
+        userId: row.user_id,
+        purpose: row.purpose,
+        invitationId: row.invitation_id,
+        tokenHash: row.token_hash,
+        expiresAt: row.expires_at,
+        usedAt: row.used_at,
+        createdAt: row.created_at,
+    });
+}
+function agentTokenFromRow(row) {
+    return AgentTokenSchema.parse({
+        id: row.id,
+        userId: row.user_id,
+        spaceId: row.space_id,
+        name: row.name,
+        prefix: row.prefix,
+        tokenHash: row.token_hash,
+        createdAt: row.created_at,
+        lastUsedAt: row.last_used_at,
+        expiresAt: row.expires_at,
+        revokedAt: row.revoked_at,
+    });
+}
+function invitationFromRow(row) {
+    return InvitationSchema.parse({
+        id: row.id,
+        spaceId: row.space_id,
+        email: row.email,
+        invitedBy: row.invited_by,
+        createdAt: row.created_at,
+        expiresAt: row.expires_at,
+        acceptedAt: row.accepted_at,
+        revokedAt: row.revoked_at,
+        declinedAt: row.declined_at,
+    });
+}
+function spaceFromRow(row) {
+    return SpaceSchema.parse({
+        id: row.id,
+        name: row.name,
+        kind: row.kind,
+        ownerId: row.owner_id,
+        keyPrefix: row.key_prefix,
+        nextTaskNumber: row.next_task_number,
+        createdAt: row.created_at,
+    });
+}
+function membershipFromRow(row) {
+    return MembershipSchema.parse({ spaceId: row.space_id, userId: row.user_id, role: row.role, joinedAt: row.joined_at });
+}
+function taskFromRow(row) {
+    return TaskSchema.parse({
+        id: row.id,
+        spaceId: row.space_id,
+        number: row.number,
+        parentId: row.parent_id,
+        depth: row.depth,
+        type: row.type,
+        title: row.title,
+        description: row.description,
+        status: row.status,
+        priority: row.priority,
+        position: row.position,
+        testedTaskId: row.tested_task_id,
+        createdBy: row.created_by,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        version: row.version,
+    });
+}
+function ideaFromRow(row) {
+    return IdeaSchema.parse({
+        id: row.id,
+        spaceId: row.space_id,
+        authorId: row.author_id,
+        text: row.text,
+        origin: row.origin,
+        requestId: row.request_id,
+        promotedTaskId: row.promoted_task_id,
+        archivedAt: row.archived_at,
+        createdAt: row.created_at,
+    });
+}
+function requestFromRow(row) {
+    return AgentRequestSchema.parse({
+        id: row.id,
+        authorId: row.author_id,
+        targetSpaceId: row.target_space_id,
+        kind: row.kind,
+        contextTaskId: row.context_task_id,
+        contextIdeaId: row.context_idea_id,
+        text: row.text,
+        status: row.status,
+        reply: row.reply,
+        failureReason: row.failure_reason,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        claimedAt: row.claimed_at,
+        claimedByTokenId: row.claimed_by_token_id,
+        completedAt: row.completed_at,
+        cancelledBy: row.cancelled_by,
+    });
+}
+function versionFromRow(row) {
+    const raw = row.snapshot === null ? null : JSON.parse(row.snapshot);
+    const snapshot = raw === null ? null : row.entity_type === "task" ? TaskSnapshotSchema.parse(raw) : IdeaSnapshotSchema.parse(raw);
+    return EntityVersionSchema.parse({
+        entityType: row.entity_type,
+        entityId: row.entity_id,
+        version: row.version,
+        snapshot,
+        actorType: row.actor_type,
+        actorId: row.actor_id,
+        requestId: row.request_id,
+        tokenId: row.token_id,
+        createdAt: row.created_at,
+    });
+}
+function changeFromRow(row) {
+    return ChangeSchema.parse({
+        seq: row.seq,
+        spaceId: row.space_id,
+        userId: row.user_id,
+        entityType: row.entity_type,
+        entityId: row.entity_id,
+        taskId: row.task_id,
+        at: row.at,
+    });
+}
+function tagFromRow(row) {
+    return TagSchema.parse({ id: row.id, spaceId: row.space_id, name: row.name });
+}
+function checklistItemFromRow(row) {
+    return ChecklistItemSchema.parse({ id: row.id, taskId: row.task_id, text: row.text, done: bool(row.done), position: row.position });
+}
+function commentFromRow(row) {
+    return CommentSchema.parse({
+        id: row.id,
+        taskId: row.task_id,
+        authorId: row.author_id,
+        body: row.body,
+        createdAt: row.created_at,
+        editedAt: row.edited_at,
+        requestId: row.request_id,
+    });
+}
+function agentActionFromRow(row) {
+    return AgentActionSchema.parse({
+        id: row.id,
+        requestId: row.request_id,
+        seq: row.seq,
+        entityType: row.entity_type,
+        entityId: row.entity_id,
+        operation: row.operation,
+        before: row.before === null ? null : JSON.parse(row.before),
+        after: row.after === null ? null : JSON.parse(row.after),
+        summary: row.summary,
+        createdAt: row.created_at,
+        undoneAt: row.undone_at,
+        undoneBy: row.undone_by,
+        tokenId: row.token_id,
+    });
+}
+function attachmentFromRow(row) {
+    return AttachmentSchema.parse({
+        id: row.id,
+        taskId: row.task_id,
+        uploaderId: row.uploader_id,
+        filename: row.filename,
+        mime: row.mime,
+        size: row.size,
+        storagePath: row.storage_path,
+        createdAt: row.created_at,
+    });
+}
+function checkpointFromRow(row) {
+    return TestCheckpointSchema.parse({ id: row.id, taskId: row.task_id, text: row.text, position: row.position });
+}
+function testResultFromRow(row) {
+    return TestResultSchema.parse({
+        checkpointId: row.checkpoint_id,
+        testerId: row.tester_id,
+        result: row.result,
+        comment: row.comment,
+        updatedAt: row.updated_at,
+    });
+}
+function testReviewFromRow(row) {
+    return TestReviewSchema.parse({
+        id: row.id,
+        taskId: row.task_id,
+        testerId: row.tester_id,
+        text: row.text,
+        submittedAt: row.submitted_at,
+        requestId: row.request_id,
+    });
+}
+function notificationFromRow(row) {
+    return NotificationSchema.parse({
+        id: row.id,
+        userId: row.user_id,
+        type: row.type,
+        taskId: row.task_id,
+        actorType: row.actor_type,
+        actorId: row.actor_id,
+        requestId: row.request_id,
+        commentId: row.comment_id,
+        inApp: bool(row.in_app),
+        createdAt: row.created_at,
+        readAt: row.read_at,
+        emailedAt: row.emailed_at,
+        emailError: row.email_error,
+    });
+}
+/** Libellé d'une tâche dans les messages : `ORG-41`. */
+function taskLabel(db, task) {
+    return `${keyPrefixOf(db, task.spaceId)}-${task.number}`;
+}
+function keyPrefixOf(db, spaceId) {
+    const row = db.prepare("SELECT key_prefix FROM spaces WHERE id = ?").get(spaceId);
+    if (!row)
+        throw new NotFoundError(`Space ${spaceId} not found.`);
+    return row.key_prefix;
+}
+// --- Store ------------------------------------------------------------------
+/**
+ * Accès à la base. Les lectures sont libres ; toute écriture passe par
+ * `mutate`, qui l'exécute dans une transaction, vérifie les invariants,
+ * enregistre les versions des entités versionnées et alimente le journal
+ * `Change`.
+ */
+export class Store {
+    db;
+    activeMutation = null;
+    emailListener = null;
+    pendingRequestListeners = new Set();
+    /** Présence des veilleurs de notifications, par jeton d'agent. */
+    watchers = new WatcherRegistry();
+    constructor(db) {
+        this.db = db;
+    }
+    /** Ouvre (et migre) la base du répertoire de données. */
+    static open(dataDir) {
+        return new Store(openDatabase(dataDir));
+    }
+    close() {
+        this.db.close();
+    }
+    // --- Utilisateurs ---
+    findUser(id) {
+        const row = this.db.prepare("SELECT * FROM users WHERE id = ?").get(id);
+        return row ? userFromRow(row) : null;
+    }
+    getUser(id) {
+        const user = this.findUser(id);
+        if (!user)
+            throw new NotFoundError(`User ${id} not found.`);
+        return user;
+    }
+    findUserByEmail(email) {
+        const row = this.db.prepare("SELECT * FROM users WHERE email = ?").get(email.trim().toLowerCase());
+        return row ? userFromRow(row) : null;
+    }
+    countUsers() {
+        return this.db.prepare("SELECT COUNT(*) AS n FROM users").get().n;
+    }
+    getUserSettings(userId) {
+        const row = this.db.prepare("SELECT * FROM user_settings WHERE user_id = ?").get(userId);
+        if (!row)
+            throw new NotFoundError(`Settings of user ${userId} not found.`);
+        return settingsFromRow(row);
+    }
+    // --- Sessions et liens d'accès ---
+    findSessionByHash(idHash) {
+        const row = this.db.prepare("SELECT * FROM sessions WHERE id_hash = ?").get(idHash);
+        return row ? sessionFromRow(row) : null;
+    }
+    findAccessLinkByHash(tokenHash) {
+        const row = this.db.prepare("SELECT * FROM access_links WHERE token_hash = ?").get(tokenHash);
+        return row ? accessLinkFromRow(row) : null;
+    }
+    /** Liens d'accès inutilisés d'un compte. */
+    listUnusedAccessLinks(userId) {
+        const rows = this.db.prepare("SELECT * FROM access_links WHERE user_id = ? AND used_at IS NULL ORDER BY created_at").all(userId);
+        return rows.map(accessLinkFromRow);
+    }
+    // --- Jetons d'agent ---
+    findAgentToken(id) {
+        const row = this.db.prepare("SELECT * FROM agent_tokens WHERE id = ?").get(id);
+        return row ? agentTokenFromRow(row) : null;
+    }
+    findAgentTokenByHash(tokenHash) {
+        const row = this.db.prepare("SELECT * FROM agent_tokens WHERE token_hash = ?").get(tokenHash);
+        return row ? agentTokenFromRow(row) : null;
+    }
+    /** Jetons qui couvrent un espace, tous propriétaires confondus, du plus récemment utilisé au moins récemment. */
+    listAgentTokensOfSpace(spaceId) {
+        const rows = this.db
+            .prepare("SELECT * FROM agent_tokens WHERE space_id = ? ORDER BY last_used_at IS NULL, last_used_at DESC, created_at DESC, id DESC")
+            .all(spaceId);
+        return rows.map(agentTokenFromRow);
+    }
+    /** Jetons d'un utilisateur, du plus récent au plus ancien. */
+    listAgentTokensOf(userId) {
+        const rows = this.db.prepare("SELECT * FROM agent_tokens WHERE user_id = ? ORDER BY created_at DESC, id DESC").all(userId);
+        return rows.map(agentTokenFromRow);
+    }
+    // --- Invitations ---
+    findInvitation(id) {
+        const row = this.db.prepare("SELECT * FROM invitations WHERE id = ?").get(id);
+        return row ? invitationFromRow(row) : null;
+    }
+    getInvitation(id) {
+        const invitation = this.findInvitation(id);
+        if (!invitation)
+            throw new NotFoundError(`Invitation ${id} not found.`);
+        return invitation;
+    }
+    /** Invitations en attente (ni acceptées, ni révoquées, ni refusées) d'un espace, par date. */
+    listOpenInvitations(spaceId) {
+        const rows = this.db
+            .prepare("SELECT * FROM invitations WHERE space_id = ? AND accepted_at IS NULL AND revoked_at IS NULL AND declined_at IS NULL ORDER BY created_at, id")
+            .all(spaceId);
+        return rows.map(invitationFromRow);
+    }
+    /** Invitations en attente adressées à une adresse, tous espaces confondus, par date. */
+    listOpenInvitationsForEmail(email) {
+        const rows = this.db
+            .prepare("SELECT * FROM invitations WHERE email = ? AND accepted_at IS NULL AND revoked_at IS NULL AND declined_at IS NULL ORDER BY created_at, id")
+            .all(email.trim().toLowerCase());
+        return rows.map(invitationFromRow);
+    }
+    // --- Espaces et membres ---
+    findSpace(id) {
+        const row = this.db.prepare("SELECT * FROM spaces WHERE id = ?").get(id);
+        return row ? spaceFromRow(row) : null;
+    }
+    getSpace(id) {
+        const space = this.findSpace(id);
+        if (!space)
+            throw new NotFoundError(`Space ${id} not found.`);
+        return space;
+    }
+    findPersonalSpace(userId) {
+        const row = this.db.prepare("SELECT * FROM spaces WHERE owner_id = ? AND kind = 'personal'").get(userId);
+        return row ? spaceFromRow(row) : null;
+    }
+    /** Espaces dont l'utilisateur est membre : son espace personnel d'abord, puis les espaces communs par nom. */
+    listSpacesOf(userId) {
+        const rows = this.db
+            .prepare(`SELECT s.* FROM spaces s JOIN memberships m ON m.space_id = s.id
+         WHERE m.user_id = ? ORDER BY s.kind = 'shared', s.name COLLATE NOCASE`)
+            .all(userId);
+        return rows.map(spaceFromRow);
+    }
+    listMemberships(spaceId) {
+        const rows = this.db.prepare("SELECT * FROM memberships WHERE space_id = ? ORDER BY joined_at, user_id").all(spaceId);
+        return rows.map(membershipFromRow);
+    }
+    findMembership(spaceId, userId) {
+        const row = this.db.prepare("SELECT * FROM memberships WHERE space_id = ? AND user_id = ?").get(spaceId, userId);
+        return row ? membershipFromRow(row) : null;
+    }
+    isMember(spaceId, userId) {
+        return this.findMembership(spaceId, userId) !== null;
+    }
+    // --- Tâches ---
+    findTask(id) {
+        const row = this.db.prepare("SELECT * FROM tasks WHERE id = ?").get(id);
+        return row ? taskFromRow(row) : null;
+    }
+    getTask(id) {
+        const task = this.findTask(id);
+        if (!task)
+            throw new NotFoundError(`Task ${id} not found.`);
+        return task;
+    }
+    /** Tâches d'un espace, par profondeur, colonne et position. */
+    listTasks(spaceId) {
+        const rows = this.db.prepare("SELECT * FROM tasks WHERE space_id = ? ORDER BY depth, status, position").all(spaceId);
+        return rows.map(taskFromRow);
+    }
+    /** Tâche d'un espace par son numéro (`41` dans `ORG-41`). */
+    findTaskByNumber(spaceId, number) {
+        const row = this.db.prepare("SELECT * FROM tasks WHERE space_id = ? AND number = ?").get(spaceId, number);
+        return row ? taskFromRow(row) : null;
+    }
+    listChildren(parentId) {
+        const rows = this.db.prepare("SELECT * FROM tasks WHERE parent_id = ? ORDER BY status, position").all(parentId);
+        return rows.map(taskFromRow);
+    }
+    listAssigneeIds(taskId) {
+        const rows = this.db.prepare("SELECT user_id FROM task_assignees WHERE task_id = ? ORDER BY user_id").all(taskId);
+        return rows.map((row) => row.user_id);
+    }
+    listTagIds(taskId) {
+        const rows = this.db.prepare("SELECT tag_id FROM task_tags WHERE task_id = ? ORDER BY tag_id").all(taskId);
+        return rows.map((row) => row.tag_id);
+    }
+    /** Instantané d'une tâche : ses champs, ses assignés et ses tags. */
+    taskSnapshot(taskId) {
+        return TaskSnapshotSchema.parse({ ...this.getTask(taskId), assigneeIds: this.listAssigneeIds(taskId), tagIds: this.listTagIds(taskId) });
+    }
+    /** Assignations des tâches d'un espace. */
+    listAssignmentsInSpace(spaceId) {
+        const rows = this.db
+            .prepare("SELECT a.task_id, a.user_id FROM task_assignees a JOIN tasks t ON t.id = a.task_id WHERE t.space_id = ? ORDER BY a.user_id")
+            .all(spaceId);
+        return rows.map((row) => ({ taskId: row.task_id, userId: row.user_id }));
+    }
+    /** Associations tâche-tag des tâches d'un espace. */
+    listTaskTagsInSpace(spaceId) {
+        const rows = this.db
+            .prepare("SELECT x.task_id, x.tag_id FROM task_tags x JOIN tasks t ON t.id = x.task_id WHERE t.space_id = ? ORDER BY x.tag_id")
+            .all(spaceId);
+        return rows.map((row) => ({ taskId: row.task_id, tagId: row.tag_id }));
+    }
+    /** Tâches d'une colonne (espace, parent, statut) par position, sans `excludeId`. */
+    listColumn(spaceId, parentId, status, excludeId = null) {
+        const rows = this.db
+            .prepare("SELECT * FROM tasks WHERE space_id = ? AND parent_id IS ? AND status = ? AND id IS NOT ? ORDER BY position")
+            .all(spaceId, parentId, status, excludeId);
+        return rows.map(taskFromRow);
+    }
+    // --- Tags ---
+    findTag(id) {
+        const row = this.db.prepare("SELECT * FROM tags WHERE id = ?").get(id);
+        return row ? tagFromRow(row) : null;
+    }
+    /** Tags d'un espace, par nom. */
+    listTags(spaceId) {
+        const rows = this.db.prepare("SELECT * FROM tags WHERE space_id = ? ORDER BY name COLLATE NOCASE").all(spaceId);
+        return rows.map(tagFromRow);
+    }
+    // --- Checklist ---
+    findChecklistItem(id) {
+        const row = this.db.prepare("SELECT * FROM checklist_items WHERE id = ?").get(id);
+        return row ? checklistItemFromRow(row) : null;
+    }
+    getChecklistItem(id) {
+        const item = this.findChecklistItem(id);
+        if (!item)
+            throw new NotFoundError(`Checklist item ${id} not found.`);
+        return item;
+    }
+    listChecklist(taskId) {
+        const rows = this.db.prepare("SELECT * FROM checklist_items WHERE task_id = ? ORDER BY position").all(taskId);
+        return rows.map(checklistItemFromRow);
+    }
+    // --- Tâches de test ---
+    findCheckpoint(id) {
+        const row = this.db.prepare("SELECT * FROM test_checkpoints WHERE id = ?").get(id);
+        return row ? checkpointFromRow(row) : null;
+    }
+    getCheckpoint(id) {
+        const checkpoint = this.findCheckpoint(id);
+        if (!checkpoint)
+            throw new NotFoundError(`Checkpoint ${id} not found.`);
+        return checkpoint;
+    }
+    /** Points de vérification d'une tâche de test, dans l'ordre. */
+    listCheckpoints(taskId) {
+        const rows = this.db.prepare("SELECT * FROM test_checkpoints WHERE task_id = ? ORDER BY position").all(taskId);
+        return rows.map(checkpointFromRow);
+    }
+    /** Résultats saisis sur les points d'une tâche, tous testeurs confondus. */
+    listTestResults(taskId) {
+        const rows = this.db
+            .prepare("SELECT r.* FROM test_results r JOIN test_checkpoints c ON c.id = r.checkpoint_id WHERE c.task_id = ? ORDER BY c.position, r.tester_id")
+            .all(taskId);
+        return rows.map(testResultFromRow);
+    }
+    findTestResult(checkpointId, testerId) {
+        const row = this.db.prepare("SELECT * FROM test_results WHERE checkpoint_id = ? AND tester_id = ?").get(checkpointId, testerId);
+        return row ? testResultFromRow(row) : null;
+    }
+    /** Reviews d'une tâche : brouillons et reviews soumises, par date de soumission. */
+    listTestReviews(taskId) {
+        const rows = this.db.prepare("SELECT * FROM test_reviews WHERE task_id = ? ORDER BY submitted_at IS NULL, submitted_at, id").all(taskId);
+        return rows.map(testReviewFromRow);
+    }
+    /** Brouillon de review d'un testeur sur une tâche. */
+    findDraftReview(taskId, testerId) {
+        const row = this.db.prepare("SELECT * FROM test_reviews WHERE task_id = ? AND tester_id = ? AND submitted_at IS NULL").get(taskId, testerId);
+        return row ? testReviewFromRow(row) : null;
+    }
+    findTestReview(id) {
+        const row = this.db.prepare("SELECT * FROM test_reviews WHERE id = ?").get(id);
+        return row ? testReviewFromRow(row) : null;
+    }
+    /** Points de vérification des tâches d'un espace. */
+    listCheckpointsInSpace(spaceId) {
+        const rows = this.db
+            .prepare("SELECT c.id, c.task_id FROM test_checkpoints c JOIN tasks t ON t.id = c.task_id WHERE t.space_id = ? ORDER BY c.position")
+            .all(spaceId);
+        return rows.map((row) => ({ id: row.id, taskId: row.task_id }));
+    }
+    /** Résultats saisis sur les points des tâches d'un espace. */
+    listTestResultsInSpace(spaceId) {
+        const rows = this.db
+            .prepare(`SELECT c.task_id, r.checkpoint_id, r.tester_id, r.result FROM test_results r
+         JOIN test_checkpoints c ON c.id = r.checkpoint_id JOIN tasks t ON t.id = c.task_id WHERE t.space_id = ?`)
+            .all(spaceId);
+        return rows.map((row) => ({
+            taskId: row.task_id,
+            checkpointId: row.checkpoint_id,
+            testerId: row.tester_id,
+            result: row.result,
+        }));
+    }
+    // --- Commentaires ---
+    findComment(id) {
+        const row = this.db.prepare("SELECT * FROM comments WHERE id = ?").get(id);
+        return row ? commentFromRow(row) : null;
+    }
+    getComment(id) {
+        const comment = this.findComment(id);
+        if (!comment)
+            throw new NotFoundError(`Comment ${id} not found.`);
+        return comment;
+    }
+    /** Commentaires d'une tâche, du plus ancien au plus récent. */
+    listComments(taskId) {
+        const rows = this.db.prepare("SELECT * FROM comments WHERE task_id = ? ORDER BY created_at, id").all(taskId);
+        return rows.map(commentFromRow);
+    }
+    // --- Pièces jointes ---
+    findAttachment(id) {
+        const row = this.db.prepare("SELECT * FROM attachments WHERE id = ?").get(id);
+        return row ? attachmentFromRow(row) : null;
+    }
+    getAttachment(id) {
+        const attachment = this.findAttachment(id);
+        if (!attachment)
+            throw new NotFoundError(`Attachment ${id} not found.`);
+        return attachment;
+    }
+    /** Pièces jointes d'une tâche, de la plus ancienne à la plus récente. */
+    listAttachments(taskId) {
+        const rows = this.db.prepare("SELECT * FROM attachments WHERE task_id = ? ORDER BY created_at, id").all(taskId);
+        return rows.map(attachmentFromRow);
+    }
+    /** Pièces jointes d'une tâche et de toutes ses sous-tâches. */
+    listAttachmentsInSubtree(taskId) {
+        const rows = this.db
+            .prepare(`WITH RECURSIVE subtree(id) AS (SELECT ? UNION ALL SELECT t.id FROM tasks t JOIN subtree s ON t.parent_id = s.id)
+         SELECT a.* FROM attachments a JOIN subtree s ON a.task_id = s.id`)
+            .all(taskId);
+        return rows.map(attachmentFromRow);
+    }
+    /** Pièces jointes des tâches d'un espace. */
+    listAttachmentsInSpace(spaceId) {
+        const rows = this.db
+            .prepare("SELECT a.* FROM attachments a JOIN tasks t ON t.id = a.task_id WHERE t.space_id = ?")
+            .all(spaceId);
+        return rows.map(attachmentFromRow);
+    }
+    // --- Idées ---
+    findIdea(id) {
+        const row = this.db.prepare("SELECT * FROM ideas WHERE id = ?").get(id);
+        return row ? ideaFromRow(row) : null;
+    }
+    getIdea(id) {
+        const idea = this.findIdea(id);
+        if (!idea)
+            throw new NotFoundError(`Idea ${id} not found.`);
+        return idea;
+    }
+    listIdeas(spaceId) {
+        const rows = this.db.prepare("SELECT * FROM ideas WHERE space_id = ? ORDER BY created_at DESC, id").all(spaceId);
+        return rows.map(ideaFromRow);
+    }
+    /** Demandes de promotion (`idea_promotion`) en attente ou en cours sur les idées d'un espace. */
+    listOpenPromotionRequests(spaceId) {
+        const rows = this.db
+            .prepare(`SELECT r.* FROM agent_requests r JOIN ideas i ON i.id = r.context_idea_id
+         WHERE i.space_id = ? AND r.kind = 'idea_promotion' AND r.status IN ('pending', 'processing') ORDER BY r.created_at, r.id`)
+            .all(spaceId);
+        return rows.map(requestFromRow);
+    }
+    /** Tâches de test qui vérifient une tâche. */
+    listTestsOf(taskId) {
+        const rows = this.db.prepare("SELECT * FROM tasks WHERE tested_task_id = ? ORDER BY number").all(taskId);
+        return rows.map(taskFromRow);
+    }
+    // --- Demandes ---
+    findAgentRequest(id) {
+        const row = this.db.prepare("SELECT * FROM agent_requests WHERE id = ?").get(id);
+        return row ? requestFromRow(row) : null;
+    }
+    getAgentRequest(id) {
+        const request = this.findAgentRequest(id);
+        if (!request)
+            throw new NotFoundError(`Request ${id} not found.`);
+        return request;
+    }
+    /**
+     * Demandes qui visent un espace, d'un statut (toutes sans statut), au plus
+     * `limit` : les demandes en attente de la plus ancienne à la plus récente,
+     * les autres de la plus récente à la plus ancienne.
+     */
+    listAgentRequestsTargeting(spaceId, status, limit) {
+        const order = status === "pending" ? "created_at, id" : "created_at DESC, id DESC";
+        const rows = this.db
+            .prepare(`SELECT * FROM agent_requests WHERE target_space_id = @spaceId AND (@status IS NULL OR status = @status) ORDER BY ${order} LIMIT @limit`)
+            .all({ spaceId, status, limit });
+        return rows.map(requestFromRow);
+    }
+    /** Demandes d'un espace, de la plus récente à la plus ancienne, au plus `limit`. */
+    listAgentRequestsOfSpace(spaceId, limit) {
+        const rows = this.db
+            .prepare("SELECT * FROM agent_requests WHERE target_space_id = @spaceId ORDER BY created_at DESC, id DESC LIMIT @limit")
+            .all({ spaceId, limit });
+        return rows.map(requestFromRow);
+    }
+    /** Nombre de demandes en attente d'un espace. */
+    countPendingRequestsOfSpace(spaceId) {
+        const row = this.db.prepare("SELECT COUNT(*) AS n FROM agent_requests WHERE status = 'pending' AND target_space_id = ?").get(spaceId);
+        return row.n;
+    }
+    // --- Actions de l'agent ---
+    findAgentAction(id) {
+        const row = this.db.prepare("SELECT * FROM agent_actions WHERE id = ?").get(id);
+        return row ? agentActionFromRow(row) : null;
+    }
+    getAgentAction(id) {
+        const action = this.findAgentAction(id);
+        if (!action)
+            throw new NotFoundError(`Agent action ${id} not found.`);
+        return action;
+    }
+    /** Actions d'une demande (son lot), dans l'ordre où l'agent les a faites. */
+    listAgentActions(requestId) {
+        const rows = this.db.prepare("SELECT * FROM agent_actions WHERE request_id = ? ORDER BY seq").all(requestId);
+        return rows.map(agentActionFromRow);
+    }
+    /** Dernière action non annulée de l'agent sur une entité. */
+    lastLiveAgentActionOn(entityType, entityId) {
+        const row = this.db
+            .prepare("SELECT * FROM agent_actions WHERE entity_type = ? AND entity_id = ? AND undone_at IS NULL ORDER BY created_at DESC, seq DESC LIMIT 1")
+            .get(entityType, entityId);
+        return row ? agentActionFromRow(row) : null;
+    }
+    /** Auteur du dernier changement enregistré d'une entité, ou null si elle n'en a aucun. */
+    lastChangeAuthor(entityType, entityId) {
+        const row = this.db
+            .prepare("SELECT actor_type, actor_id, request_id FROM changes WHERE entity_type = ? AND entity_id = ? AND actor_type IS NOT NULL ORDER BY seq DESC LIMIT 1")
+            .get(entityType, entityId);
+        if (!row)
+            return null;
+        return { actorType: row.actor_type, actorId: row.actor_id ?? null, requestId: row.request_id ?? null };
+    }
+    // --- Notifications ---
+    findNotification(id) {
+        const row = this.db.prepare("SELECT * FROM notifications WHERE id = ?").get(id);
+        return row ? notificationFromRow(row) : null;
+    }
+    getNotification(id) {
+        const notification = this.findNotification(id);
+        if (!notification)
+            throw new NotFoundError(`Notification ${id} not found.`);
+        return notification;
+    }
+    /**
+     * Notifications affichées dans l'application d'un utilisateur, sur les
+     * tâches des espaces dont il est encore membre : non lues d'abord, puis de
+     * la plus récente à la plus ancienne.
+     */
+    listNotifications(userId, limit, offset) {
+        const rows = this.db
+            .prepare(`SELECT n.* FROM notifications n JOIN tasks t ON t.id = n.task_id
+         JOIN memberships m ON m.space_id = t.space_id AND m.user_id = n.user_id
+         WHERE n.user_id = ? AND n.in_app = 1
+         ORDER BY n.read_at IS NOT NULL, n.created_at DESC, n.id DESC LIMIT ? OFFSET ?`)
+            .all(userId, limit, offset);
+        return rows.map(notificationFromRow);
+    }
+    /** Nombre de notifications non lues affichées dans l'application d'un utilisateur. */
+    countUnreadNotifications(userId) {
+        const row = this.db
+            .prepare(`SELECT COUNT(*) AS n FROM notifications n JOIN tasks t ON t.id = n.task_id
+         JOIN memberships m ON m.space_id = t.space_id AND m.user_id = n.user_id
+         WHERE n.user_id = ? AND n.in_app = 1 AND n.read_at IS NULL`)
+            .get(userId);
+        return row.n;
+    }
+    // --- Historique et journal ---
+    findVersion(entityType, entityId, version) {
+        const row = this.db
+            .prepare("SELECT * FROM entity_versions WHERE entity_type = ? AND entity_id = ? AND version = ?")
+            .get(entityType, entityId, version);
+        return row ? versionFromRow(row) : null;
+    }
+    listVersions(entityType, entityId) {
+        const rows = this.db
+            .prepare("SELECT * FROM entity_versions WHERE entity_type = ? AND entity_id = ? ORDER BY version")
+            .all(entityType, entityId);
+        return rows.map(versionFromRow);
+    }
+    /** Changements de numéro strictement supérieur à `since`, dans l'ordre. */
+    listChangesSince(since) {
+        const rows = this.db.prepare("SELECT * FROM changes WHERE seq > ? ORDER BY seq").all(since);
+        return rows.map(changeFromRow);
+    }
+    /**
+     * Changements postérieurs à `since` qui concernent un utilisateur : ceux des
+     * espaces dont il est membre et ceux qui le visent, au plus `limit`, dans l'ordre.
+     */
+    listChangesForUser(userId, since, limit) {
+        const rows = this.db
+            .prepare(`SELECT * FROM changes WHERE seq > ?
+           AND (user_id = ? OR space_id IN (SELECT space_id FROM memberships WHERE user_id = ?))
+         ORDER BY seq LIMIT ?`)
+            .all(since, userId, userId, limit);
+        return rows.map(changeFromRow);
+    }
+    /** Numéro du dernier changement, 0 si le journal est vide. */
+    lastChangeSeq() {
+        return this.db.prepare("SELECT COALESCE(MAX(seq), 0) AS seq FROM changes").get().seq;
+    }
+    // --- Mutation ---
+    /**
+     * Abonne `listener` aux notifications dont le destinataire veut un e-mail :
+     * il reçoit leurs identifiants après la validation de la mutation qui les a
+     * créées.
+     */
+    setEmailListener(listener) {
+        this.emailListener = listener;
+    }
+    /**
+     * Abonne `listener` aux demandes qui passent en attente (créées, ou
+     * libérées par un membre) : il les reçoit après la validation de la
+     * mutation. La fonction rendue désabonne.
+     */
+    onPendingRequest(listener) {
+        this.pendingRequestListeners.add(listener);
+        return () => this.pendingRequestListeners.delete(listener);
+    }
+    /**
+     * Point unique d'écriture. `fn` reçoit une `Mutation` et s'exécute dans une
+     * transaction exclusive ; à sa sortie, les invariants sont vérifiés sur l'état
+     * final, les versions et le journal sont écrits. Toute erreur annule
+     * l'ensemble.
+     */
+    mutate(actor, fn) {
+        if (this.activeMutation)
+            throw new Error("Store.mutate is not reentrant: use the Mutation passed to the running mutation.");
+        let emails = [];
+        let pending = [];
+        const run = this.db.transaction(() => {
+            const tx = new Mutation(this, actor);
+            this.activeMutation = tx;
+            try {
+                const result = fn(tx);
+                tx.finish();
+                emails = tx.emailNotificationIds;
+                pending = tx.pendingRequestIds;
+                return result;
+            }
+            finally {
+                this.activeMutation = null;
+            }
+        });
+        const result = run.immediate();
+        if (emails.length > 0 && this.emailListener)
+            this.emailListener(emails);
+        if (pending.length > 0 && this.pendingRequestListeners.size > 0) {
+            for (const id of pending) {
+                const request = this.getAgentRequest(id);
+                for (const listener of [...this.pendingRequestListeners])
+                    listener(request);
+            }
+        }
+        return result;
+    }
+}
+const VERSIONED = new Set(["task", "idea"]);
+/**
+ * Écritures d'une mutation en cours. Chaque méthode applique une modification
+ * et la note ; `finish` vérifie les invariants et écrit versions et journal.
+ */
+export class Mutation {
+    store;
+    actor;
+    /** Horodatage commun à toutes les écritures de la mutation. */
+    now = new Date().toISOString();
+    touched = new Map();
+    /** Notifications créées par la mutation dont le destinataire veut un e-mail. */
+    emailNotificationIds = [];
+    /** Demandes passées en attente par la mutation : créées, ou libérées. */
+    pendingRequestIds = [];
+    /** Demande pour laquelle agit l'agent, lue au début de la mutation. */
+    request;
+    /** Jeton avec lequel agit l'agent. */
+    token;
+    /** Vrai une fois vérifié que l'agent peut écrire pour sa demande. */
+    agentWriteChecked = false;
+    /** Demandes créées par la mutation, dont l'espace cible est vérifié. */
+    createdRequestIds = new Set();
+    db;
+    constructor(store, actor) {
+        this.store = store;
+        this.actor = actor;
+        this.db = store.db;
+        if (actor.type === "agent") {
+            this.request = this.loadAgentRequest(actor.requestId);
+            this.token = this.store.findAgentToken(actor.tokenId);
+            if (!this.token)
+                throw new NotFoundError(`Agent token ${actor.tokenId} not found.`);
+        }
+        else {
+            this.request = null;
+            this.token = null;
+        }
+    }
+    /** Utilisateur au nom de qui la mutation s'exécute : l'utilisateur, ou le propriétaire du jeton de l'agent. */
+    get actingUserId() {
+        return this.actor.type === "user" ? this.actor.userId : this.token.userId;
+    }
+    loadAgentRequest(requestId) {
+        const request = this.store.findAgentRequest(requestId);
+        if (!request)
+            throw new NotFoundError(`Request ${requestId} not found. Call list_requests to get valid request ids.`);
+        return request;
+    }
+    /** La demande de l'agent vise l'espace de son jeton. */
+    assertRequestInTokenSpace(request, token) {
+        if (request.targetSpaceId !== token.spaceId) {
+            throw new ForbiddenError(`Request ${request.id} belongs to another space than the one your token covers. Call list_requests to get the requests of your space.`);
+        }
+    }
+    /** La demande est `processing` et prise par le jeton de l'agent. */
+    assertClaimedByToken(request, token) {
+        if (request.status === "pending")
+            throw new InvariantError(`Request ${request.id} is pending: call claim_request on it first.`);
+        if (request.status !== "processing") {
+            throw new InvariantError(`Request ${request.id} is ${request.status}, not processing: it is closed. Call list_requests to pick a pending request.`);
+        }
+        if (request.claimedByTokenId !== token.id) {
+            throw new ForbiddenError(`Request ${request.id} was claimed by another agent token: only that agent can act for it. Call list_requests to pick a pending request.`);
+        }
+    }
+    /**
+     * L'agent n'écrit que pour une demande `processing` prise par son jeton,
+     * dans l'espace du jeton, dont le propriétaire est toujours membre.
+     * Vérifié à la première écriture d'une entité autre que la demande elle-même.
+     */
+    assertAgentMayWrite() {
+        const request = this.request;
+        const token = this.token;
+        if (!request || !token || this.agentWriteChecked)
+            return;
+        this.assertRequestInTokenSpace(request, token);
+        this.assertClaimedByToken(request, token);
+        if (!this.store.isMember(request.targetSpaceId, token.userId)) {
+            throw new ForbiddenError(`The owner of your agent token is no longer a member of the space of request ${request.id}: the agent cannot act there.`);
+        }
+        this.agentWriteChecked = true;
+    }
+    touch(entityType, entityId, spaceId, userId, taskId = null) {
+        if (entityType !== "agent_request")
+            this.assertAgentMayWrite();
+        const key = `${entityType}:${entityId}`;
+        const concernedTask = entityType === "task" ? entityId : taskId;
+        if (!this.touched.has(key))
+            this.touched.set(key, { entityType, entityId, spaceId, userId, taskId: concernedTask });
+    }
+    // --- Utilisateurs ---
+    createUser(input) {
+        const user = validate(UserSchema, {
+            id: input.id ?? newId(),
+            email: input.email,
+            displayName: input.displayName ?? null,
+            passwordHash: input.passwordHash ?? null,
+            status: input.status,
+            createdAt: this.now,
+        }, "user");
+        if (user.status !== "invited" && user.displayName === null) {
+            throw new OrganizerError(`An ${user.status} account needs a display name.`);
+        }
+        if (this.store.findUserByEmail(user.email))
+            throw new InvariantError(`An account already exists for ${user.email}.`);
+        this.db
+            .prepare("INSERT INTO users (id, email, display_name, password_hash, status, created_at) VALUES (?, ?, ?, ?, ?, ?)")
+            .run(user.id, user.email, user.displayName, user.passwordHash, user.status, user.createdAt);
+        this.db.prepare("INSERT INTO user_settings (user_id) VALUES (?)").run(user.id);
+        this.touch("user", user.id, null, user.id);
+        return user;
+    }
+    updateUser(id, patch) {
+        const current = this.store.getUser(id);
+        const user = validate(UserSchema, { ...current, ...definedFields(patch) }, "user");
+        if (user.status !== "invited" && user.displayName === null) {
+            throw new OrganizerError(`An ${user.status} account needs a display name.`);
+        }
+        this.db
+            .prepare("UPDATE users SET display_name = ?, password_hash = ?, status = ? WHERE id = ?")
+            .run(user.displayName, user.passwordHash, user.status, id);
+        this.touch("user", id, null, id);
+        return user;
+    }
+    // --- Sessions et liens d'accès ---
+    createSession(session) {
+        const valid = validate(SessionSchema, session, "session");
+        this.store.getUser(valid.userId);
+        this.db
+            .prepare("INSERT INTO sessions (id_hash, user_id, created_at, expires_at) VALUES (?, ?, ?, ?)")
+            .run(valid.idHash, valid.userId, valid.createdAt, valid.expiresAt);
+        return valid;
+    }
+    extendSession(idHash, expiresAt) {
+        this.db.prepare("UPDATE sessions SET expires_at = ? WHERE id_hash = ?").run(expiresAt, idHash);
+    }
+    deleteSession(idHash) {
+        this.db.prepare("DELETE FROM sessions WHERE id_hash = ?").run(idHash);
+    }
+    /** Ferme les sessions d'un compte, sauf celle de `keepIdHash`. */
+    deleteSessionsOf(userId, keepIdHash = null) {
+        this.db.prepare("DELETE FROM sessions WHERE user_id = ? AND id_hash IS NOT ?").run(userId, keepIdHash);
+    }
+    /** Supprime les sessions expirées à l'instant `now`. */
+    deleteExpiredSessions(now) {
+        this.db.prepare("DELETE FROM sessions WHERE expires_at <= ?").run(now);
+    }
+    /**
+     * Émet un lien d'accès pour un compte. Un lien d'invitation est rattaché à
+     * son invitation, adressée à ce compte, et remplace le lien inutilisé de
+     * cette seule invitation ; un lien de réinitialisation remplace les liens de
+     * réinitialisation inutilisés du compte.
+     */
+    createAccessLink(input) {
+        const user = this.store.getUser(input.userId);
+        const link = validate(AccessLinkSchema, { id: newId(), ...input, usedAt: null, createdAt: this.now }, "access link");
+        if ((link.purpose === "invite") !== (link.invitationId !== null)) {
+            throw new InvariantError("An invitation link belongs to exactly one invitation, and only an invitation link does.");
+        }
+        if (link.invitationId !== null) {
+            const invitation = this.openInvitation(link.invitationId);
+            if (invitation.email !== user.email)
+                throw new InvariantError(`Invitation ${invitation.id} is not addressed to ${user.email}.`);
+        }
+        this.db
+            .prepare("DELETE FROM access_links WHERE user_id = ? AND purpose = ? AND invitation_id IS ? AND used_at IS NULL")
+            .run(link.userId, link.purpose, link.invitationId);
+        this.db
+            .prepare("INSERT INTO access_links (id, user_id, purpose, invitation_id, token_hash, expires_at, used_at, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)")
+            .run(link.id, link.userId, link.purpose, link.invitationId, link.tokenHash, link.expiresAt, link.usedAt, link.createdAt);
+        return link;
+    }
+    /** Supprime les liens inutilisés d'un compte, qui ne fonctionnent plus. */
+    discardUnusedAccessLinks(userId) {
+        this.db.prepare("DELETE FROM access_links WHERE user_id = ? AND used_at IS NULL").run(userId);
+    }
+    /** Supprime les liens inutilisés émis par une invitation. */
+    discardInvitationLinks(invitationId) {
+        this.db.prepare("DELETE FROM access_links WHERE invitation_id = ? AND used_at IS NULL").run(invitationId);
+    }
+    markAccessLinkUsed(id) {
+        const result = this.db.prepare("UPDATE access_links SET used_at = ? WHERE id = ? AND used_at IS NULL").run(this.now, id);
+        if (result.changes !== 1)
+            throw new InvariantError("This access link has already been used.");
+    }
+    // --- Jetons d'agent ---
+    /** Enregistre un jeton d'agent de l'utilisateur acteur ; seul son hash est conservé. */
+    createAgentToken(input) {
+        if (this.actor.type !== "user")
+            throw new InvariantError("Only a user can create an agent token.");
+        const token = validate(AgentTokenSchema, { id: newId(), userId: this.actor.userId, ...input, createdAt: this.now, lastUsedAt: null, revokedAt: null }, "agent token");
+        if (!this.store.isMember(token.spaceId, token.userId))
+            throw new ForbiddenError("An agent token can only cover a space its owner is a member of.");
+        this.db
+            .prepare(`INSERT INTO agent_tokens (id, user_id, space_id, name, prefix, token_hash, created_at, expires_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(token.id, token.userId, token.spaceId, token.name, token.prefix, token.tokenHash, token.createdAt, token.expiresAt);
+        this.touch("agent_token", token.id, null, token.userId);
+        return token;
+    }
+    /** Révoque un jeton de l'utilisateur acteur ; un jeton déjà révoqué reste tel quel. */
+    revokeAgentToken(id) {
+        const token = this.store.findAgentToken(id);
+        if (!token || this.actor.type !== "user" || token.userId !== this.actor.userId)
+            throw new NotFoundError(`Agent token ${id} not found.`);
+        if (token.revokedAt !== null)
+            return token;
+        this.db.prepare("UPDATE agent_tokens SET revoked_at = ? WHERE id = ?").run(this.now, id);
+        this.touch("agent_token", id, null, token.userId);
+        return { ...token, revokedAt: this.now };
+    }
+    /** Date du dernier usage d'un jeton ; le journal des changements n'en garde pas trace. */
+    recordAgentTokenUse(id, at) {
+        this.db.prepare("UPDATE agent_tokens SET last_used_at = ? WHERE id = ?").run(at, id);
+    }
+    // --- Invitations ---
+    /** Invite une adresse dans un espace, jusqu'à `expiresAt`. */
+    createInvitation(input) {
+        const space = this.store.getSpace(input.spaceId);
+        const invitation = validate(InvitationSchema, {
+            id: newId(),
+            spaceId: space.id,
+            email: input.email,
+            invitedBy: this.actingUserId,
+            createdAt: this.now,
+            expiresAt: input.expiresAt,
+            acceptedAt: null,
+            revokedAt: null,
+            declinedAt: null,
+        }, "invitation");
+        const open = this.store.listOpenInvitations(space.id).find((existing) => existing.email === invitation.email);
+        if (open)
+            throw new InvariantError(`${invitation.email} already has a pending invitation to space "${space.name}".`);
+        this.db
+            .prepare("INSERT INTO invitations (id, space_id, email, invited_by, created_at, expires_at) VALUES (?, ?, ?, ?, ?, ?)")
+            .run(invitation.id, invitation.spaceId, invitation.email, invitation.invitedBy, invitation.createdAt, invitation.expiresAt);
+        this.touchInvitation(invitation);
+        return invitation;
+    }
+    /** Repousse l'échéance d'une invitation en attente. */
+    renewInvitation(id, expiresAt) {
+        const invitation = this.openInvitation(id);
+        const renewed = validate(InvitationSchema, { ...invitation, expiresAt }, "invitation");
+        this.db.prepare("UPDATE invitations SET expires_at = ? WHERE id = ?").run(renewed.expiresAt, id);
+        this.touchInvitation(invitation);
+        return renewed;
+    }
+    /** Révoque une invitation en attente ; ses liens inutilisés ne fonctionnent plus. */
+    revokeInvitation(id) {
+        const invitation = this.openInvitation(id);
+        this.db.prepare("UPDATE invitations SET revoked_at = ? WHERE id = ?").run(this.now, id);
+        this.discardInvitationLinks(id);
+        this.touchInvitation(invitation);
+        return { ...invitation, revokedAt: this.now };
+    }
+    acceptInvitation(id) {
+        const invitation = this.openInvitation(id);
+        this.db.prepare("UPDATE invitations SET accepted_at = ? WHERE id = ?").run(this.now, id);
+        this.touchInvitation(invitation);
+        return { ...invitation, acceptedAt: this.now };
+    }
+    /** Refus d'une invitation en attente par son destinataire ; ses liens inutilisés ne fonctionnent plus. */
+    declineInvitation(id) {
+        const invitation = this.openInvitation(id);
+        this.db.prepare("UPDATE invitations SET declined_at = ? WHERE id = ?").run(this.now, id);
+        this.discardInvitationLinks(id);
+        this.touchInvitation(invitation);
+        return { ...invitation, declinedAt: this.now };
+    }
+    openInvitation(id) {
+        const invitation = this.store.getInvitation(id);
+        if (invitation.acceptedAt !== null)
+            throw new InvariantError(`The invitation of ${invitation.email} has already been accepted.`);
+        if (invitation.revokedAt !== null)
+            throw new InvariantError(`The invitation of ${invitation.email} has been revoked.`);
+        if (invitation.declinedAt !== null)
+            throw new InvariantError(`The invitation of ${invitation.email} has been declined.`);
+        return invitation;
+    }
+    /** Note la modification d'une invitation, pour son espace et pour le compte de son destinataire. */
+    touchInvitation(invitation) {
+        this.touch("invitation", invitation.id, invitation.spaceId, this.store.findUserByEmail(invitation.email)?.id ?? null);
+    }
+    // --- Espaces et membres ---
+    /** Crée un espace et en fait de son propriétaire le membre `owner`. */
+    createSpace(input) {
+        const space = validate(SpaceSchema, { id: newId(), name: input.name, kind: input.kind, ownerId: input.ownerId, keyPrefix: input.keyPrefix, nextTaskNumber: 1, createdAt: this.now }, "space");
+        this.store.getUser(space.ownerId);
+        if (space.kind === "personal" && this.store.findPersonalSpace(space.ownerId)) {
+            throw new InvariantError(`User ${space.ownerId} already has a personal space.`);
+        }
+        this.db
+            .prepare("INSERT INTO spaces (id, name, kind, owner_id, key_prefix, next_task_number, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)")
+            .run(space.id, space.name, space.kind, space.ownerId, space.keyPrefix, space.nextTaskNumber, space.createdAt);
+        this.touch("space", space.id, space.id, null);
+        this.insertMembership(space.id, space.ownerId, "owner");
+        return space;
+    }
+    renameSpace(id, name) {
+        const space = validate(SpaceSchema, { ...this.store.getSpace(id), name }, "space");
+        this.db.prepare("UPDATE spaces SET name = ? WHERE id = ?").run(space.name, id);
+        this.touch("space", id, id, null);
+        return space;
+    }
+    /** Supprime un espace commun et tout son contenu. Un espace personnel ne se supprime pas. */
+    deleteSpace(id) {
+        const space = this.store.getSpace(id);
+        if (space.kind === "personal")
+            throw new InvariantError("A personal space cannot be deleted.");
+        for (const membership of this.store.listMemberships(id)) {
+            this.touch("membership", `${id}:${membership.userId}`, id, membership.userId);
+        }
+        this.db
+            .prepare(`DELETE FROM entity_versions WHERE (entity_type = 'task' AND entity_id IN (SELECT id FROM tasks WHERE space_id = ?))
+         OR (entity_type = 'idea' AND entity_id IN (SELECT id FROM ideas WHERE space_id = ?))`)
+            .run(id, id);
+        this.db.prepare("DELETE FROM spaces WHERE id = ?").run(id);
+        this.touch("space", id, id, null);
+    }
+    addMember(spaceId, userId, role = "member") {
+        this.store.getSpace(spaceId);
+        this.store.getUser(userId);
+        if (this.store.isMember(spaceId, userId))
+            throw new InvariantError(`User ${userId} is already a member of space ${spaceId}.`);
+        return this.insertMembership(spaceId, userId, role);
+    }
+    setMemberRole(spaceId, userId, role) {
+        const membership = this.store.findMembership(spaceId, userId);
+        if (!membership)
+            throw new NotFoundError(`User ${userId} is not a member of space ${spaceId}.`);
+        this.db.prepare("UPDATE memberships SET role = ? WHERE space_id = ? AND user_id = ?").run(role, spaceId, userId);
+        this.touch("membership", `${spaceId}:${userId}`, spaceId, userId);
+        return { ...membership, role };
+    }
+    /** Retire un membre d'un espace et révoque ses jetons d'agent sur cet espace. */
+    removeMember(spaceId, userId) {
+        if (!this.store.findMembership(spaceId, userId))
+            throw new NotFoundError(`User ${userId} is not a member of space ${spaceId}.`);
+        this.db.prepare("DELETE FROM memberships WHERE space_id = ? AND user_id = ?").run(spaceId, userId);
+        this.touch("membership", `${spaceId}:${userId}`, spaceId, userId);
+        const tokenIds = this.db.prepare("SELECT id FROM agent_tokens WHERE space_id = ? AND user_id = ? AND revoked_at IS NULL").pluck().all(spaceId, userId);
+        this.db.prepare("UPDATE agent_tokens SET revoked_at = ? WHERE space_id = ? AND user_id = ? AND revoked_at IS NULL").run(this.now, spaceId, userId);
+        for (const id of tokenIds)
+            this.touch("agent_token", id, null, userId);
+    }
+    insertMembership(spaceId, userId, role) {
+        const membership = validate(MembershipSchema, { spaceId, userId, role, joinedAt: this.now }, "membership");
+        this.db.prepare("INSERT INTO memberships (space_id, user_id, role, joined_at) VALUES (?, ?, ?, ?)").run(spaceId, userId, role, this.now);
+        this.touch("membership", `${spaceId}:${userId}`, spaceId, userId);
+        return membership;
+    }
+    // --- Tâches ---
+    createTask(input) {
+        const space = this.store.getSpace(input.spaceId);
+        const parentId = input.parentId ?? null;
+        const depth = parentId === null ? 0 : this.childDepth(this.store.getTask(parentId), space.id);
+        const status = input.status ?? "todo";
+        const task = validate(TaskSchema, {
+            id: newId(),
+            spaceId: space.id,
+            number: space.nextTaskNumber,
+            parentId,
+            depth,
+            type: input.type ?? "standard",
+            title: input.title,
+            description: input.description ?? "",
+            status,
+            priority: input.priority ?? "medium",
+            position: input.position ?? this.endOfColumn(space.id, parentId, status, null),
+            testedTaskId: null,
+            createdBy: this.actingUserId,
+            createdAt: this.now,
+            updatedAt: this.now,
+            version: 1,
+        }, "task");
+        this.db
+            .prepare(`INSERT INTO tasks (id, space_id, number, parent_id, depth, type, title, description, status, priority, position,
+                            created_by, created_at, updated_at, version)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(task.id, task.spaceId, task.number, task.parentId, task.depth, task.type, task.title, task.description, task.status, task.priority, task.position, task.createdBy, task.createdAt, task.updatedAt, task.version);
+        this.db.prepare("UPDATE spaces SET next_task_number = next_task_number + 1 WHERE id = ?").run(space.id);
+        this.touch("task", task.id, task.spaceId, null);
+        return task;
+    }
+    /**
+     * Modifie une tâche. Un changement de parent recalcule la profondeur de toute
+     * la sous-arborescence ; un changement de colonne sans position place la
+     * tâche en fin de colonne. Une tâche qui devient standard perd sa tâche testée.
+     */
+    updateTask(id, patch) {
+        const current = this.store.getTask(id);
+        const fields = definedFields(patch);
+        const parentId = fields.parentId === undefined ? current.parentId : fields.parentId;
+        const status = fields.status ?? current.status;
+        let depth = current.depth;
+        if (parentId !== current.parentId) {
+            depth = parentId === null ? 0 : this.childDepth(this.store.getTask(parentId), current.spaceId);
+            if (parentId !== null && this.isInSubtree(parentId, id)) {
+                throw new InvariantError(`Task ${taskLabel(this.db, current)} cannot be moved under itself or one of its own sub-tasks.`);
+            }
+            const height = this.subtreeHeight(id);
+            if (depth + height > MAX_TASK_DEPTH) {
+                throw new InvariantError(`Moving task ${taskLabel(this.db, current)} there would nest its sub-tasks deeper than ${MAX_TASK_DEPTH} levels. Move or flatten its sub-tasks first.`);
+            }
+        }
+        const columnChanged = parentId !== current.parentId || status !== current.status;
+        const position = fields.position ?? (columnChanged ? this.endOfColumn(current.spaceId, parentId, status, id) : current.position);
+        const type = fields.type ?? current.type;
+        const testedTaskId = fields.testedTaskId !== undefined ? fields.testedTaskId : type === "standard" ? null : current.testedTaskId;
+        const task = validate(TaskSchema, { ...current, ...fields, parentId, depth, status, position, testedTaskId, updatedAt: this.now }, "task");
+        this.db
+            .prepare(`UPDATE tasks SET parent_id = ?, depth = ?, type = ?, title = ?, description = ?, status = ?, priority = ?,
+                          position = ?, tested_task_id = ?, updated_at = ? WHERE id = ?`)
+            .run(task.parentId, task.depth, task.type, task.title, task.description, task.status, task.priority, task.position, task.testedTaskId, task.updatedAt, id);
+        this.touch("task", id, task.spaceId, null);
+        if (task.depth !== current.depth)
+            this.updateDescendantDepths(id, task.depth);
+        return task;
+    }
+    /**
+     * Supprime une tâche et ses sous-tâches ; chacune reçoit une version de
+     * suppression. Les tâches de test qui vérifiaient une tâche supprimée
+     * perdent ce lien, avec une nouvelle version.
+     */
+    deleteTask(id) {
+        const task = this.store.getTask(id);
+        for (const child of this.store.listChildren(id))
+            this.deleteTask(child.id);
+        for (const test of this.store.listTestsOf(id)) {
+            if (test.id === id)
+                continue;
+            this.db.prepare("UPDATE tasks SET tested_task_id = NULL, updated_at = ? WHERE id = ?").run(this.now, test.id);
+            this.touch("task", test.id, test.spaceId, null);
+        }
+        this.db.prepare("DELETE FROM tasks WHERE id = ?").run(id);
+        this.touch("task", id, task.spaceId, null);
+    }
+    /** Remplace les assignés (ou testeurs) d'une tâche. */
+    setAssignees(taskId, userIds) {
+        const task = this.store.getTask(taskId);
+        const unique = [...new Set(userIds)].sort();
+        for (const userId of unique)
+            this.store.getUser(userId);
+        const previous = new Set(this.store.listAssigneeIds(taskId));
+        this.db.prepare("DELETE FROM task_assignees WHERE task_id = ?").run(taskId);
+        const insert = this.db.prepare("INSERT INTO task_assignees (task_id, user_id) VALUES (?, ?)");
+        for (const userId of unique)
+            insert.run(taskId, userId);
+        this.db.prepare("UPDATE tasks SET updated_at = ? WHERE id = ?").run(this.now, taskId);
+        this.touch("task", taskId, task.spaceId, null);
+        for (const userId of unique) {
+            if (previous.has(userId) || this.isActingUser(userId))
+                continue;
+            this.notify("assigned", userId, taskId, null);
+        }
+        return unique;
+    }
+    /**
+     * Déplace une tâche dans la colonne `status` de son parent, juste après
+     * `afterId` (null : en tête de colonne). Son rang est pris entre ses deux
+     * nouvelles voisines ; quand leur écart est trop faible, la colonne est
+     * renumérotée.
+     */
+    moveTask(id, status, afterId) {
+        const task = this.store.getTask(id);
+        const column = this.store.listColumn(task.spaceId, task.parentId, status, id);
+        const position = this.slotAfter(column, afterId, `Task ${afterId} is not in the ${status} column of task ${taskLabel(this.db, task)}`, (ids) => {
+            const update = this.db.prepare("UPDATE tasks SET position = ? WHERE id = ?");
+            ids.forEach((taskId, index) => {
+                update.run(index + 1, taskId);
+                this.touch("task", taskId, task.spaceId, null);
+            });
+        });
+        return this.updateTask(id, { status, position });
+    }
+    /** Remplace les tags d'une tâche ; un nom absent de l'espace y crée le tag (noms comparés sans la casse). */
+    setTags(taskId, names) {
+        const task = this.store.getTask(taskId);
+        const existing = this.store.listTags(task.spaceId);
+        const tags = [];
+        for (const raw of names) {
+            const name = raw.trim();
+            if (tags.some((tag) => tag.name.toLowerCase() === name.toLowerCase()))
+                continue;
+            tags.push(existing.find((tag) => tag.name.toLowerCase() === name.toLowerCase()) ?? this.createTag(task.spaceId, name));
+        }
+        this.db.prepare("DELETE FROM task_tags WHERE task_id = ?").run(taskId);
+        const insert = this.db.prepare("INSERT INTO task_tags (task_id, tag_id) VALUES (?, ?)");
+        for (const tag of tags)
+            insert.run(taskId, tag.id);
+        this.db.prepare("UPDATE tasks SET updated_at = ? WHERE id = ?").run(this.now, taskId);
+        this.touch("task", taskId, task.spaceId, null);
+        return tags;
+    }
+    createTag(spaceId, name) {
+        const tag = validate(TagSchema, { id: newId(), spaceId, name }, "tag");
+        this.db.prepare("INSERT INTO tags (id, space_id, name) VALUES (?, ?, ?)").run(tag.id, tag.spaceId, tag.name);
+        this.touch("tag", tag.id, spaceId, null);
+        return tag;
+    }
+    // --- Checklist ---
+    /** Ajoute un élément en fin de checklist d'une tâche standard. */
+    addChecklistItem(taskId, text) {
+        const task = this.store.getTask(taskId);
+        if (task.type !== "standard") {
+            throw new InvariantError(`Task ${taskLabel(this.db, task)} is a test: it has checkpoints, not a checklist.`);
+        }
+        const items = this.store.listChecklist(taskId);
+        const item = validate(ChecklistItemSchema, { id: newId(), taskId, text, done: false, position: positionBetween(items.at(-1)?.position ?? null, null) }, "checklist item");
+        this.db
+            .prepare("INSERT INTO checklist_items (id, task_id, text, done, position) VALUES (?, ?, ?, ?, ?)")
+            .run(item.id, item.taskId, item.text, item.done ? 1 : 0, item.position);
+        this.touch("checklist_item", item.id, task.spaceId, null, taskId);
+        return item;
+    }
+    updateChecklistItem(id, patch) {
+        const current = this.store.getChecklistItem(id);
+        const item = validate(ChecklistItemSchema, { ...current, ...definedFields(patch) }, "checklist item");
+        this.db.prepare("UPDATE checklist_items SET text = ?, done = ?, position = ? WHERE id = ?").run(item.text, item.done ? 1 : 0, item.position, id);
+        this.touch("checklist_item", id, this.store.getTask(item.taskId).spaceId, null, item.taskId);
+        return item;
+    }
+    deleteChecklistItem(id) {
+        const item = this.store.getChecklistItem(id);
+        this.db.prepare("DELETE FROM checklist_items WHERE id = ?").run(id);
+        this.touch("checklist_item", id, this.store.getTask(item.taskId).spaceId, null, item.taskId);
+    }
+    /** Recrée un élément de checklist supprimé, avec son identifiant et sa position. */
+    restoreChecklistItem(snapshot) {
+        const item = validate(ChecklistItemSchema, snapshot, "checklist item");
+        const task = this.store.getTask(item.taskId);
+        if (task.type !== "standard")
+            throw new InvariantError(`Task ${taskLabel(this.db, task)} is a test: it has checkpoints, not a checklist.`);
+        this.db
+            .prepare("INSERT INTO checklist_items (id, task_id, text, done, position) VALUES (?, ?, ?, ?, ?)")
+            .run(item.id, item.taskId, item.text, item.done ? 1 : 0, item.position);
+        this.touch("checklist_item", item.id, task.spaceId, null, task.id);
+        return item;
+    }
+    /** Place un élément de checklist juste après `afterId` (null : en tête), en renumérotant la liste si besoin. */
+    moveChecklistItem(id, afterId) {
+        const item = this.store.getChecklistItem(id);
+        const spaceId = this.store.getTask(item.taskId).spaceId;
+        const others = this.store.listChecklist(item.taskId).filter((other) => other.id !== id);
+        const position = this.slotAfter(others, afterId, `Checklist item ${afterId} is not in the same checklist`, (ids) => {
+            const update = this.db.prepare("UPDATE checklist_items SET position = ? WHERE id = ?");
+            ids.forEach((itemId, index) => {
+                update.run(index + 1, itemId);
+                this.touch("checklist_item", itemId, spaceId, null, item.taskId);
+            });
+        });
+        return this.updateChecklistItemPosition(item, position, spaceId);
+    }
+    updateChecklistItemPosition(item, position, spaceId) {
+        this.db.prepare("UPDATE checklist_items SET position = ? WHERE id = ?").run(position, item.id);
+        this.touch("checklist_item", item.id, spaceId, null, item.taskId);
+        return { ...item, position };
+    }
+    /**
+     * Rang d'un élément inséré juste après `afterId` (null : en tête) dans
+     * `items`, triés par rang. Quand les voisins sont trop proches, `renumber`
+     * reçoit les identifiants dans l'ordre et leur donne les rangs 1, 2, 3…
+     */
+    slotAfter(items, afterId, notFound, renumber) {
+        let index = 0;
+        if (afterId !== null) {
+            const at = items.findIndex((item) => item.id === afterId);
+            if (at < 0)
+                throw new InvariantError(`${notFound}: reload and try again.`);
+            index = at + 1;
+        }
+        const position = positionBetween(index > 0 ? items[index - 1].position : null, index < items.length ? items[index].position : null);
+        if (position !== null)
+            return position;
+        renumber(items.map((item) => item.id));
+        return positionBetween(index > 0 ? index : null, index < items.length ? index + 1 : null);
+    }
+    // --- Tâches de test ---
+    /** Tâche de test qui porte des points de vérification. */
+    testTask(taskId) {
+        const task = this.store.getTask(taskId);
+        if (task.type !== "test") {
+            throw new InvariantError(`Task ${taskLabel(this.db, task)} is a standard task: it has a checklist, not test checkpoints.`);
+        }
+        return task;
+    }
+    /** Tâche de test dont l'utilisateur acteur est testeur (assigné). */
+    testedTask(taskId) {
+        const task = this.testTask(taskId);
+        if (!this.store.listAssigneeIds(taskId).includes(this.actingUserId)) {
+            throw new ForbiddenError(`Only the testers (assignees) of task ${taskLabel(this.db, task)} can record results and reviews; assign the user first.`);
+        }
+        return task;
+    }
+    /** Ajoute un point de vérification en fin de liste d'une tâche de test. */
+    addCheckpoint(taskId, text) {
+        const task = this.testTask(taskId);
+        const checkpoints = this.store.listCheckpoints(taskId);
+        const checkpoint = validate(TestCheckpointSchema, { id: newId(), taskId, text, position: positionBetween(checkpoints.at(-1)?.position ?? null, null) }, "checkpoint");
+        this.db
+            .prepare("INSERT INTO test_checkpoints (id, task_id, text, position) VALUES (?, ?, ?, ?)")
+            .run(checkpoint.id, checkpoint.taskId, checkpoint.text, checkpoint.position);
+        this.touch("test_checkpoint", checkpoint.id, task.spaceId, null, taskId);
+        return checkpoint;
+    }
+    updateCheckpoint(id, text) {
+        const current = this.store.getCheckpoint(id);
+        const checkpoint = validate(TestCheckpointSchema, { ...current, text }, "checkpoint");
+        this.db.prepare("UPDATE test_checkpoints SET text = ? WHERE id = ?").run(checkpoint.text, id);
+        this.touch("test_checkpoint", id, this.store.getTask(checkpoint.taskId).spaceId, null, checkpoint.taskId);
+        return checkpoint;
+    }
+    /** Supprime un point de vérification et les résultats saisis dessus. */
+    deleteCheckpoint(id) {
+        const checkpoint = this.store.getCheckpoint(id);
+        this.db.prepare("DELETE FROM test_checkpoints WHERE id = ?").run(id);
+        this.touch("test_checkpoint", id, this.store.getTask(checkpoint.taskId).spaceId, null, checkpoint.taskId);
+    }
+    /** Recrée un point de vérification supprimé, avec son identifiant, sa position et les résultats saisis dessus. */
+    restoreCheckpoint(snapshot, results) {
+        const checkpoint = validate(TestCheckpointSchema, snapshot, "checkpoint");
+        const task = this.testTask(checkpoint.taskId);
+        this.db
+            .prepare("INSERT INTO test_checkpoints (id, task_id, text, position) VALUES (?, ?, ?, ?)")
+            .run(checkpoint.id, checkpoint.taskId, checkpoint.text, checkpoint.position);
+        this.touch("test_checkpoint", checkpoint.id, task.spaceId, null, task.id);
+        const insert = this.db.prepare("INSERT INTO test_results (checkpoint_id, tester_id, result, comment, updated_at) VALUES (?, ?, ?, ?, ?)");
+        for (const raw of results) {
+            const result = validate(TestResultSchema, raw, "test result");
+            if (result.checkpointId !== checkpoint.id)
+                throw new InvariantError(`Test result of checkpoint ${result.checkpointId} cannot be restored on checkpoint ${checkpoint.id}.`);
+            insert.run(result.checkpointId, result.testerId, result.result, result.comment, result.updatedAt);
+            this.touch("test_result", `${result.checkpointId}:${result.testerId}`, task.spaceId, null, task.id);
+        }
+        return checkpoint;
+    }
+    /** Place un point de vérification juste après `afterId` (null : en tête), en renumérotant la liste si besoin. */
+    moveCheckpoint(id, afterId) {
+        const checkpoint = this.store.getCheckpoint(id);
+        const spaceId = this.store.getTask(checkpoint.taskId).spaceId;
+        const others = this.store.listCheckpoints(checkpoint.taskId).filter((other) => other.id !== id);
+        const update = this.db.prepare("UPDATE test_checkpoints SET position = ? WHERE id = ?");
+        const position = this.slotAfter(others, afterId, `Checkpoint ${afterId} is not in the same test`, (ids) => {
+            ids.forEach((checkpointId, index) => {
+                update.run(index + 1, checkpointId);
+                this.touch("test_checkpoint", checkpointId, spaceId, null, checkpoint.taskId);
+            });
+        });
+        update.run(position, id);
+        this.touch("test_checkpoint", id, spaceId, null, checkpoint.taskId);
+        return { ...checkpoint, position };
+    }
+    /**
+     * Enregistre le résultat de l'utilisateur acteur sur un point : valeur,
+     * commentaire, ou les deux. Seul un testeur de la tâche saisit ses propres
+     * résultats ; un point sans résultat vaut « untested ».
+     */
+    setTestResult(checkpointId, patch) {
+        const checkpoint = this.store.getCheckpoint(checkpointId);
+        const task = this.testedTask(checkpoint.taskId);
+        const testerId = this.actingUserId;
+        const current = this.store.findTestResult(checkpointId, testerId);
+        const result = validate(TestResultSchema, {
+            checkpointId,
+            testerId,
+            result: patch.result ?? current?.result ?? "untested",
+            comment: patch.comment ?? current?.comment ?? "",
+            updatedAt: this.now,
+        }, "test result");
+        this.db
+            .prepare(`INSERT INTO test_results (checkpoint_id, tester_id, result, comment, updated_at) VALUES (?, ?, ?, ?, ?)
+         ON CONFLICT (checkpoint_id, tester_id) DO UPDATE SET result = excluded.result, comment = excluded.comment, updated_at = excluded.updated_at`)
+            .run(result.checkpointId, result.testerId, result.result, result.comment, result.updatedAt);
+        this.touch("test_result", `${checkpointId}:${testerId}`, task.spaceId, null, task.id);
+        return result;
+    }
+    /** Enregistre le brouillon de review de l'utilisateur acteur, testeur de la tâche. */
+    saveReviewDraft(taskId, text) {
+        const task = this.testedTask(taskId);
+        const draft = this.store.findDraftReview(taskId, this.actingUserId);
+        const review = validate(TestReviewSchema, draft ? { ...draft, text } : { id: newId(), taskId, testerId: this.actingUserId, text, submittedAt: null, requestId: null }, "test review");
+        if (draft) {
+            this.db.prepare("UPDATE test_reviews SET text = ? WHERE id = ?").run(review.text, review.id);
+        }
+        else {
+            this.db
+                .prepare("INSERT INTO test_reviews (id, task_id, tester_id, text, submitted_at, request_id) VALUES (?, ?, ?, ?, NULL, NULL)")
+                .run(review.id, review.taskId, review.testerId, review.text);
+        }
+        this.touch("test_review", review.id, task.spaceId, null, taskId);
+        return review;
+    }
+    /**
+     * Soumet la review de l'utilisateur acteur avec le texte `text` : le
+     * brouillon est figé (date de soumission) et une demande `test_review` est
+     * déposée pour l'agent, dans l'espace de la tâche, avec la tâche pour contexte.
+     */
+    submitReview(taskId, text) {
+        const task = this.testedTask(taskId);
+        if (text.trim() === "")
+            throw new OrganizerError(`The review of task ${taskLabel(this.db, task)} is empty: write what you observed before submitting it.`);
+        const draft = this.saveReviewDraft(taskId, text.trim());
+        const request = this.createAgentRequest({
+            targetSpaceId: task.spaceId,
+            kind: "test_review",
+            text: draft.text,
+            contextTaskId: task.id,
+        });
+        this.db.prepare("UPDATE test_reviews SET submitted_at = ?, request_id = ? WHERE id = ?").run(this.now, request.id, draft.id);
+        return { review: { ...draft, submittedAt: this.now, requestId: request.id }, request };
+    }
+    // --- Commentaires ---
+    /** Commentaire de l'utilisateur acteur sur une tâche. */
+    addComment(taskId, body) {
+        const task = this.store.getTask(taskId);
+        const comment = validate(CommentSchema, { id: newId(), taskId, authorId: this.actingUserId, body, createdAt: this.now, editedAt: null, requestId: this.request?.id ?? null }, "comment");
+        this.db
+            .prepare("INSERT INTO comments (id, task_id, author_id, body, created_at, edited_at, request_id) VALUES (?, ?, ?, ?, ?, ?, ?)")
+            .run(comment.id, comment.taskId, comment.authorId, comment.body, comment.createdAt, comment.editedAt, comment.requestId);
+        this.touch("comment", comment.id, task.spaceId, null, taskId);
+        const commenters = this.store.listComments(taskId).filter((other) => other.id !== comment.id).map((other) => other.authorId);
+        const recipients = [...new Set([...this.store.listAssigneeIds(taskId), ...commenters])].sort();
+        for (const userId of recipients) {
+            if (this.isActingUser(userId) || !this.store.isMember(task.spaceId, userId))
+                continue;
+            this.notify("comment", userId, taskId, comment.id);
+        }
+        return comment;
+    }
+    /** Modifie un commentaire ; seul son auteur le peut. */
+    updateComment(id, body) {
+        const current = this.authoredComment(id, "edit");
+        const comment = validate(CommentSchema, { ...current, body, editedAt: this.now }, "comment");
+        this.db.prepare("UPDATE comments SET body = ?, edited_at = ? WHERE id = ?").run(comment.body, comment.editedAt, id);
+        this.touch("comment", id, this.store.getTask(comment.taskId).spaceId, null, comment.taskId);
+        return comment;
+    }
+    /** Supprime un commentaire ; seul son auteur le peut. */
+    deleteComment(id) {
+        const comment = this.authoredComment(id, "delete");
+        this.db.prepare("DELETE FROM comments WHERE id = ?").run(id);
+        this.touch("comment", id, this.store.getTask(comment.taskId).spaceId, null, comment.taskId);
+    }
+    /** Supprime un commentaire écrit par l'agent, quel que soit l'utilisateur acteur : annulation de l'action qui l'a créé. */
+    deleteAgentComment(id) {
+        const comment = this.store.getComment(id);
+        if (comment.requestId === null)
+            throw new ForbiddenError("Only a comment written by the agent can be removed by undoing its action.");
+        this.db.prepare("DELETE FROM comments WHERE id = ?").run(id);
+        this.touch("comment", id, this.store.getTask(comment.taskId).spaceId, null, comment.taskId);
+    }
+    authoredComment(id, action) {
+        const comment = this.store.getComment(id);
+        if (comment.authorId !== this.actingUserId)
+            throw new ForbiddenError(`Only the author of a comment can ${action} it.`);
+        return comment;
+    }
+    // --- Pièces jointes ---
+    /** Enregistre une pièce jointe dont le fichier est déjà écrit sous `storagePath`. */
+    createAttachment(input) {
+        const task = this.store.getTask(input.taskId);
+        const attachment = validate(AttachmentSchema, { ...input, uploaderId: this.actingUserId, createdAt: this.now }, "attachment");
+        this.db
+            .prepare("INSERT INTO attachments (id, task_id, uploader_id, filename, mime, size, storage_path, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)")
+            .run(attachment.id, attachment.taskId, attachment.uploaderId, attachment.filename, attachment.mime, attachment.size, attachment.storagePath, attachment.createdAt);
+        this.touch("attachment", attachment.id, task.spaceId, null, task.id);
+        return attachment;
+    }
+    /** Supprime l'enregistrement d'une pièce jointe et le renvoie ; son fichier reste à effacer. */
+    deleteAttachment(id) {
+        const attachment = this.store.getAttachment(id);
+        this.db.prepare("DELETE FROM attachments WHERE id = ?").run(id);
+        this.touch("attachment", id, this.store.getTask(attachment.taskId).spaceId, null, attachment.taskId);
+        return attachment;
+    }
+    /** Profondeur d'un enfant de `parent`, qui doit être dans l'espace `spaceId` et laisser place à un niveau de plus. */
+    childDepth(parent, spaceId) {
+        if (parent.spaceId !== spaceId)
+            throw new InvariantError(`Parent task ${taskLabel(this.db, parent)} belongs to another space.`);
+        if (parent.depth >= MAX_TASK_DEPTH) {
+            throw new InvariantError(`Task ${taskLabel(this.db, parent)} is already at depth ${parent.depth}: sub-tasks are limited to ${MAX_TASK_DEPTH} levels (task > sub-task > sub-sub-task).`);
+        }
+        return parent.depth + 1;
+    }
+    /** Vrai si `taskId` est `rootId` ou l'une de ses sous-tâches. */
+    isInSubtree(taskId, rootId) {
+        const seen = new Set();
+        let current = taskId;
+        while (current !== null) {
+            if (current === rootId)
+                return true;
+            if (seen.has(current))
+                return true;
+            seen.add(current);
+            const row = this.db.prepare("SELECT parent_id FROM tasks WHERE id = ?").get(current);
+            current = row?.parent_id ?? null;
+        }
+        return false;
+    }
+    /** Nombre de niveaux de sous-tâches sous `taskId` (0 sans sous-tâche). */
+    subtreeHeight(taskId) {
+        const children = this.store.listChildren(taskId);
+        return children.length === 0 ? 0 : 1 + Math.max(...children.map((child) => this.subtreeHeight(child.id)));
+    }
+    updateDescendantDepths(parentId, parentDepth) {
+        for (const child of this.store.listChildren(parentId)) {
+            this.db.prepare("UPDATE tasks SET depth = ?, updated_at = ? WHERE id = ?").run(parentDepth + 1, this.now, child.id);
+            this.touch("task", child.id, child.spaceId, null);
+            this.updateDescendantDepths(child.id, parentDepth + 1);
+        }
+    }
+    /** Position après la dernière tâche de la colonne (espace, parent, statut), en ignorant `excludeId`. */
+    endOfColumn(spaceId, parentId, status, excludeId) {
+        const row = this.db
+            .prepare("SELECT MAX(position) AS max FROM tasks WHERE space_id = ? AND parent_id IS ? AND status = ? AND id IS NOT ?")
+            .get(spaceId, parentId, status, excludeId);
+        return row.max === null ? 1 : Math.floor(row.max) + 1;
+    }
+    // --- Idées ---
+    createIdea(input) {
+        this.store.getSpace(input.spaceId);
+        const idea = validate(IdeaSchema, {
+            id: newId(),
+            spaceId: input.spaceId,
+            authorId: this.actingUserId,
+            text: input.text,
+            origin: input.origin ?? (this.actor.type === "agent" ? "agent" : "manual"),
+            requestId: this.request?.id ?? null,
+            promotedTaskId: null,
+            archivedAt: null,
+            createdAt: this.now,
+        }, "idea");
+        this.db
+            .prepare(`INSERT INTO ideas (id, space_id, author_id, text, origin, request_id, promoted_task_id, archived_at, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(idea.id, idea.spaceId, idea.authorId, idea.text, idea.origin, idea.requestId, idea.promotedTaskId, idea.archivedAt, idea.createdAt);
+        this.touch("idea", idea.id, idea.spaceId, null);
+        return idea;
+    }
+    updateIdea(id, patch) {
+        const current = this.store.getIdea(id);
+        const next = { ...current };
+        if (patch.text !== undefined)
+            next.text = patch.text;
+        if (patch.promotedTaskId !== undefined) {
+            if (patch.promotedTaskId !== null && this.store.getTask(patch.promotedTaskId).spaceId !== current.spaceId) {
+                throw new InvariantError("An idea can only be promoted to a task of its own space.");
+            }
+            next.promotedTaskId = patch.promotedTaskId;
+        }
+        if (patch.archived !== undefined)
+            next.archivedAt = patch.archived ? (current.archivedAt ?? this.now) : null;
+        const idea = validate(IdeaSchema, next, "idea");
+        this.db
+            .prepare("UPDATE ideas SET text = ?, promoted_task_id = ?, archived_at = ? WHERE id = ?")
+            .run(idea.text, idea.promotedTaskId, idea.archivedAt, id);
+        this.touch("idea", id, idea.spaceId, null);
+        return idea;
+    }
+    /** Supprime une idée ; sa version de suppression a un instantané nul. */
+    deleteIdea(id) {
+        const idea = this.store.getIdea(id);
+        this.db.prepare("DELETE FROM ideas WHERE id = ?").run(id);
+        this.touch("idea", id, idea.spaceId, null);
+    }
+    // --- Demandes ---
+    /** Dépose une demande `pending` de l'utilisateur acteur. */
+    createAgentRequest(input) {
+        if (this.actor.type !== "user")
+            throw new InvariantError("Only a user can create a request for the agent.");
+        const request = validate(AgentRequestSchema, {
+            id: newId(),
+            authorId: this.actor.userId,
+            targetSpaceId: input.targetSpaceId,
+            kind: input.kind,
+            contextTaskId: input.contextTaskId ?? null,
+            contextIdeaId: input.contextIdeaId ?? null,
+            text: input.text,
+            status: "pending",
+            reply: null,
+            failureReason: null,
+            createdAt: this.now,
+            updatedAt: this.now,
+            claimedAt: null,
+            claimedByTokenId: null,
+            completedAt: null,
+            cancelledBy: null,
+        }, "request");
+        this.store.getSpace(request.targetSpaceId);
+        this.db
+            .prepare(`INSERT INTO agent_requests (id, author_id, target_space_id, kind, context_task_id, context_idea_id,
+                                     text, status, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(request.id, request.authorId, request.targetSpaceId, request.kind, request.contextTaskId, request.contextIdeaId, request.text, request.status, request.createdAt, request.updatedAt);
+        this.createdRequestIds.add(request.id);
+        this.pendingRequestIds.push(request.id);
+        this.touchRequest(request);
+        return request;
+    }
+    /** Note la modification d'une demande, pour son espace. */
+    touchRequest(request) {
+        this.touch("agent_request", request.id, request.targetSpaceId, request.authorId, request.contextTaskId);
+    }
+    /** Demande `pending` qu'un membre de son espace modifie ou annule. */
+    pendingRequestForUser(id, action) {
+        if (this.actor.type !== "user")
+            throw new InvariantError(`Only a user can ${action} a request.`);
+        const request = this.store.getAgentRequest(id);
+        if (!this.store.isMember(request.targetSpaceId, this.actor.userId)) {
+            throw new ForbiddenError(`Only members of the space where the request was written can ${action} it.`);
+        }
+        if (request.status !== "pending") {
+            throw new InvariantError(`Request ${id} is ${request.status}: only a pending request can be ${action === "edit" ? "edited" : "cancelled"}.`);
+        }
+        return request;
+    }
+    /** Remplace le texte d'une demande en attente. */
+    updateAgentRequestText(id, text) {
+        const current = this.pendingRequestForUser(id, "edit");
+        const request = validate(AgentRequestSchema, { ...current, text, updatedAt: this.now }, "request");
+        this.db.prepare("UPDATE agent_requests SET text = ?, updated_at = ? WHERE id = ?").run(request.text, request.updatedAt, id);
+        this.touchRequest(request);
+        return request;
+    }
+    /** Annule une demande en attente : l'agent ne la traitera pas. */
+    cancelAgentRequest(id) {
+        const current = this.pendingRequestForUser(id, "cancel");
+        const request = validate(AgentRequestSchema, { ...current, status: "cancelled", cancelledBy: this.actingUserId, updatedAt: this.now }, "request");
+        this.db.prepare("UPDATE agent_requests SET status = 'cancelled', cancelled_by = ?, updated_at = ? WHERE id = ?").run(request.cancelledBy, this.now, id);
+        this.touchRequest(request);
+        return request;
+    }
+    /** Repasse en attente une demande `processing` : un agent pourra la reprendre. */
+    releaseAgentRequest(id) {
+        if (this.actor.type !== "user")
+            throw new InvariantError("Only a user can release a request.");
+        const current = this.store.getAgentRequest(id);
+        if (current.status !== "processing")
+            throw new InvariantError(`Request ${id} is ${current.status}: only a processing request can be released.`);
+        this.db.prepare("UPDATE agent_requests SET status = 'pending', claimed_at = NULL, claimed_by_token_id = NULL, updated_at = ? WHERE id = ?").run(this.now, id);
+        const released = this.store.getAgentRequest(id);
+        this.pendingRequestIds.push(id);
+        this.touchRequest(released);
+        return released;
+    }
+    /** Demande et jeton de l'agent acteur. */
+    agentRequest() {
+        if (!this.request || !this.token)
+            throw new InvariantError("Only the agent can claim, complete or fail a request, or record an agent action.");
+        return { request: this.request, token: this.token };
+    }
+    /**
+     * L'agent prend sa demande avec son jeton : `pending` devient `processing`
+     * et la demande est réservée à ce jeton. La mise à jour conditionnelle, dans
+     * la transaction exclusive, garantit qu'un seul agent prend une demande donnée.
+     */
+    claimAgentRequest() {
+        const { request, token } = this.agentRequest();
+        this.assertRequestInTokenSpace(request, token);
+        const result = this.db
+            .prepare("UPDATE agent_requests SET status = 'processing', claimed_at = ?, claimed_by_token_id = ?, updated_at = ? WHERE id = ? AND status = 'pending'")
+            .run(this.now, token.id, this.now, request.id);
+        if (result.changes !== 1) {
+            throw new InvariantError(`Request ${request.id} is ${request.status}: only a pending request can be claimed. Call list_requests to find pending requests.`);
+        }
+        const claimed = this.store.getAgentRequest(request.id);
+        this.touchRequest(claimed);
+        return claimed;
+    }
+    /** Termine la demande de l'agent avec son message de compte rendu. */
+    completeAgentRequest(reply) {
+        return this.finishAgentRequest("done", reply, "reply");
+    }
+    /** Termine la demande de l'agent en échec, avec la raison montrée à son auteur. */
+    failAgentRequest(reason) {
+        return this.finishAgentRequest("failed", reason, "reason");
+    }
+    finishAgentRequest(status, message, what) {
+        const { request, token } = this.agentRequest();
+        this.assertRequestInTokenSpace(request, token);
+        if (request.status !== "processing") {
+            throw new InvariantError(`Request ${request.id} is ${request.status}, not processing: only a claimed request can be completed or failed.`);
+        }
+        this.assertClaimedByToken(request, token);
+        const text = message.trim();
+        if (text === "")
+            throw new OrganizerError(`The ${what} is empty: write a short message for the author of the request.`);
+        const column = status === "done" ? "reply" : "failure_reason";
+        this.db
+            .prepare(`UPDATE agent_requests SET status = ?, ${column} = ?, completed_at = ?, updated_at = ? WHERE id = ?`)
+            .run(status, text, this.now, this.now, request.id);
+        const finished = this.store.getAgentRequest(request.id);
+        this.touchRequest(finished);
+        return finished;
+    }
+    // --- Actions de l'agent ---
+    /** Enregistre une action de l'agent dans le lot de sa demande, avec le rang suivant. */
+    recordAgentAction(input) {
+        const { request, token } = this.agentRequest();
+        const next = this.db.prepare("SELECT COALESCE(MAX(seq), 0) + 1 AS seq FROM agent_actions WHERE request_id = ?").get(request.id);
+        const action = validate(AgentActionSchema, {
+            id: newId(),
+            requestId: request.id,
+            seq: next.seq,
+            entityType: input.entityType,
+            entityId: input.entityId,
+            operation: input.operation,
+            before: input.before ?? null,
+            after: input.after ?? null,
+            summary: input.summary,
+            createdAt: this.now,
+            undoneAt: null,
+            undoneBy: null,
+            tokenId: token.id,
+        }, "agent action");
+        this.db
+            .prepare(`INSERT INTO agent_actions (id, request_id, seq, entity_type, entity_id, operation, before, after, summary, created_at, token_id)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(action.id, action.requestId, action.seq, action.entityType, action.entityId, action.operation, action.before === null ? null : JSON.stringify(action.before), action.after === null ? null : JSON.stringify(action.after), action.summary, action.createdAt, action.tokenId);
+        this.touch("agent_action", action.id, request.targetSpaceId, null, input.taskId);
+        return action;
+    }
+    /** Marque annulée une action de l'agent, par l'utilisateur acteur. */
+    markAgentActionUndone(id, taskId) {
+        if (this.actor.type !== "user")
+            throw new InvariantError("Only a user can undo an agent action.");
+        const action = this.store.getAgentAction(id);
+        if (action.undoneAt !== null)
+            throw new InvariantError(`Agent action ${id} has already been undone.`);
+        this.db.prepare("UPDATE agent_actions SET undone_at = ?, undone_by = ? WHERE id = ?").run(this.now, this.actor.userId, id);
+        this.touch("agent_action", id, this.store.getAgentRequest(action.requestId).targetSpaceId, null, taskId);
+        return { ...action, undoneAt: this.now, undoneBy: this.actor.userId };
+    }
+    // --- Notifications ---
+    /** Vrai si l'utilisateur est l'auteur humain de la mutation : on ne se notifie pas soi-même. */
+    isActingUser(userId) {
+        return this.actor.type === "user" && this.actor.userId === userId;
+    }
+    /**
+     * Notifie un utilisateur selon ses préférences : la notification apparaît
+     * dans l'application si elle y est activée, et son identifiant est retenu
+     * pour l'envoi de l'e-mail si celui-ci est activé. Rien n'est créé quand les
+     * deux sont désactivés.
+     */
+    notify(type, userId, taskId, commentId) {
+        const settings = this.store.getUserSettings(userId);
+        const inApp = type === "assigned" ? settings.notifyAssignApp : settings.notifyCommentApp;
+        const email = type === "assigned" ? settings.notifyAssignEmail : settings.notifyCommentEmail;
+        if (!inApp && !email)
+            return;
+        const notification = validate(NotificationSchema, {
+            id: newId(),
+            userId,
+            type,
+            taskId,
+            actorType: this.actor.type,
+            actorId: this.actor.type === "user" ? this.actor.userId : null,
+            requestId: this.request?.id ?? null,
+            commentId,
+            inApp,
+            createdAt: this.now,
+            readAt: null,
+            emailedAt: null,
+            emailError: null,
+        }, "notification");
+        this.db
+            .prepare(`INSERT INTO notifications (id, user_id, type, task_id, actor_type, actor_id, request_id, comment_id, in_app, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(notification.id, notification.userId, notification.type, notification.taskId, notification.actorType, notification.actorId, notification.requestId, notification.commentId, inApp ? 1 : 0, notification.createdAt);
+        if (inApp)
+            this.touch("notification", notification.id, null, userId, taskId);
+        if (email)
+            this.emailNotificationIds.push(notification.id);
+    }
+    /** Marque lue une notification de l'utilisateur acteur. */
+    markNotificationRead(id) {
+        const notification = this.store.getNotification(id);
+        if (notification.userId !== this.actingUserId)
+            throw new ForbiddenError("Only the recipient of a notification can mark it as read.");
+        if (notification.readAt !== null)
+            return;
+        this.db.prepare("UPDATE notifications SET read_at = ? WHERE id = ?").run(this.now, id);
+        this.touch("notification", id, null, notification.userId, notification.taskId);
+    }
+    /** Marque lues toutes les notifications de l'utilisateur acteur ; renvoie leur nombre. */
+    markAllNotificationsRead() {
+        const userId = this.actingUserId;
+        const rows = this.db.prepare("SELECT id, task_id FROM notifications WHERE user_id = ? AND in_app = 1 AND read_at IS NULL").all(userId);
+        const update = this.db.prepare("UPDATE notifications SET read_at = ? WHERE id = ?");
+        for (const row of rows) {
+            update.run(this.now, row.id);
+            this.touch("notification", row.id, null, userId, row.task_id);
+        }
+        return rows.length;
+    }
+    /** Enregistre l'issue de l'envoi de l'e-mail d'une notification : date d'envoi ou raison de l'échec. */
+    recordNotificationEmail(id, outcome) {
+        const notification = this.store.getNotification(id);
+        const recorded = validate(NotificationSchema, { ...notification, emailedAt: outcome.sent ? this.now : null, emailError: outcome.sent ? null : outcome.reason }, "notification");
+        this.db.prepare("UPDATE notifications SET emailed_at = ?, email_error = ? WHERE id = ?").run(recorded.emailedAt, recorded.emailError, id);
+        if (notification.inApp)
+            this.touch("notification", id, null, notification.userId, notification.taskId);
+        return recorded;
+    }
+    /** Modifie les préférences d'un utilisateur. */
+    updateUserSettings(userId, patch) {
+        const settings = validate(UserSettingsSchema, { ...this.store.getUserSettings(userId), ...definedFields(patch) }, "settings");
+        this.db
+            .prepare(`UPDATE user_settings SET notify_assign_app = ?, notify_assign_email = ?, notify_comment_app = ?, notify_comment_email = ?
+         WHERE user_id = ?`)
+            .run(settings.notifyAssignApp ? 1 : 0, settings.notifyAssignEmail ? 1 : 0, settings.notifyCommentApp ? 1 : 0, settings.notifyCommentEmail ? 1 : 0, userId);
+        this.touch("user_settings", userId, null, userId);
+        return settings;
+    }
+    // --- Fin de mutation ---
+    /** Vérifie les invariants sur l'état final, puis écrit les versions et le journal. */
+    finish() {
+        this.checkInvariants();
+        this.writeVersions();
+        this.writeChanges();
+    }
+    checkInvariants() {
+        if (this.actor.type === "user" && !this.store.findUser(this.actor.userId)) {
+            throw new InvariantError(`Acting user ${this.actor.userId} does not exist.`);
+        }
+        if (this.request)
+            this.checkAgentScope(this.request);
+        const spaceIds = new Set();
+        for (const entry of this.touched.values())
+            if (entry.spaceId !== null)
+                spaceIds.add(entry.spaceId);
+        for (const spaceId of spaceIds) {
+            const space = this.store.findSpace(spaceId);
+            if (space)
+                this.checkSpace(space);
+        }
+        for (const entry of this.touched.values()) {
+            if (entry.entityType === "task") {
+                const task = this.store.findTask(entry.entityId);
+                if (task)
+                    this.checkTask(task);
+            }
+            else if (entry.entityType === "agent_request" && this.createdRequestIds.has(entry.entityId)) {
+                const request = this.store.findAgentRequest(entry.entityId);
+                if (request)
+                    this.checkRequestTarget(request);
+            }
+        }
+    }
+    /**
+     * L'agent ne touche que sa demande et des entités de l'espace cible de
+     * celle-ci ; les notifications qu'il crée visent des personnes, pas un espace.
+     */
+    checkAgentScope(request) {
+        for (const entry of this.touched.values()) {
+            if (entry.entityType === "notification")
+                continue;
+            if (entry.entityType === "agent_request" && entry.entityId === request.id)
+                continue;
+            if (entry.spaceId !== request.targetSpaceId) {
+                throw new InvariantError(`Request ${request.id} targets space ${request.targetSpaceId}; the agent cannot modify ${entry.entityType} ${entry.entityId} outside of it.`);
+            }
+        }
+    }
+    /**
+     * Un espace personnel a exactement un membre, son propriétaire, et aucune
+     * invitation ; un espace commun a exactement un `owner`, son propriétaire.
+     * Les assignés (et testeurs) de ses tâches sont membres de l'espace ; les
+     * résultats et reviews d'un ancien testeur restent en historique.
+     */
+    checkSpace(space) {
+        const members = this.store.listMemberships(space.id);
+        if (space.kind === "personal") {
+            if (members.length !== 1 || members[0].userId !== space.ownerId || members[0].role !== "owner") {
+                throw new InvariantError(`Personal space "${space.name}" must have exactly one member, its owner.`);
+            }
+            const invitations = this.db.prepare("SELECT COUNT(*) AS n FROM invitations WHERE space_id = ?").get(space.id);
+            if (invitations.n > 0)
+                throw new InvariantError(`Nobody can be invited to personal space "${space.name}".`);
+        }
+        else {
+            const owners = members.filter((member) => member.role === "owner");
+            if (owners.length !== 1) {
+                throw new InvariantError(`Shared space "${space.name}" must have exactly one owner (found ${owners.length}).`);
+            }
+            if (owners[0].userId !== space.ownerId) {
+                throw new InvariantError(`The owner member of shared space "${space.name}" must be its owner ${space.ownerId}.`);
+            }
+        }
+        const outsiders = this.db
+            .prepare(`SELECT t.number AS number, x.user_id AS user_id FROM task_assignees x JOIN tasks t ON t.id = x.task_id
+         WHERE t.space_id = ? AND NOT EXISTS (SELECT 1 FROM memberships m WHERE m.space_id = t.space_id AND m.user_id = x.user_id)
+         ORDER BY t.number LIMIT 1`)
+            .get(space.id);
+        if (outsiders) {
+            throw new InvariantError(`User ${outsiders.user_id} is assigned to ${space.keyPrefix}-${outsiders.number} but is not a member of space "${space.name}". Unassign them first.`);
+        }
+    }
+    /**
+     * Profondeur, parent dans le même espace, absence de cycle, position unique
+     * dans la colonne ; tâche testée portée par une tâche de test, dans le même
+     * espace, autre qu'elle-même.
+     */
+    checkTask(task) {
+        const label = taskLabel(this.db, task);
+        if (task.testedTaskId !== null) {
+            if (task.type !== "test")
+                throw new InvariantError(`Task ${label} is a standard task: only a test task can point to the task it tests.`);
+            if (task.testedTaskId === task.id)
+                throw new InvariantError(`Test ${label} cannot test itself.`);
+            const tested = this.store.findTask(task.testedTaskId);
+            if (!tested)
+                throw new InvariantError(`The task tested by ${label} does not exist.`);
+            if (tested.spaceId !== task.spaceId)
+                throw new InvariantError(`Test ${label} can only test a task of its own space.`);
+        }
+        if (task.parentId === null) {
+            if (task.depth !== 0)
+                throw new InvariantError(`Task ${label} has no parent but depth ${task.depth}.`);
+        }
+        else {
+            const parent = this.store.findTask(task.parentId);
+            if (!parent)
+                throw new InvariantError(`Parent of task ${label} does not exist.`);
+            if (parent.spaceId !== task.spaceId)
+                throw new InvariantError(`Task ${label} and its parent belong to different spaces.`);
+            if (task.depth !== parent.depth + 1 || task.depth > MAX_TASK_DEPTH) {
+                throw new InvariantError(`Task ${label} is at depth ${task.depth} under a parent at depth ${parent.depth} (maximum depth ${MAX_TASK_DEPTH}).`);
+            }
+            if (this.isInSubtree(task.parentId, task.id))
+                throw new InvariantError(`Task ${label} is its own ancestor.`);
+        }
+        const clash = this.db
+            .prepare("SELECT number FROM tasks WHERE space_id = ? AND parent_id IS ? AND status = ? AND position = ? AND id <> ? LIMIT 1")
+            .get(task.spaceId, task.parentId, task.status, task.position, task.id);
+        if (clash) {
+            throw new InvariantError(`Task ${label} has the same position (${task.position}) as task ${keyPrefixOf(this.db, task.spaceId)}-${clash.number} in its column. Choose a free position.`);
+        }
+    }
+    /**
+     * Une demande vise l'espace où elle est écrite, dont son auteur est membre.
+     * Une promotion d'idée vise l'espace de son idée, qui n'a pas d'autre
+     * promotion ouverte.
+     */
+    checkRequestTarget(request) {
+        if (!this.store.isMember(request.targetSpaceId, request.authorId)) {
+            throw new InvariantError("A request can only be created from a space its author is a member of.");
+        }
+        if (request.kind === "idea_promotion") {
+            const idea = request.contextIdeaId === null ? null : this.store.findIdea(request.contextIdeaId);
+            if (!idea || idea.spaceId !== request.targetSpaceId)
+                throw new InvariantError("An idea promotion request targets the space of its context idea.");
+            const open = this.store.listOpenPromotionRequests(idea.spaceId).filter((other) => other.contextIdeaId === idea.id);
+            if (open.length > 1)
+                throw new InvariantError("The promotion of this idea is already pending with the agent.");
+        }
+    }
+    /** Une version par entité versionnée modifiée ; une suppression a un instantané nul. */
+    writeVersions() {
+        const actorType = this.actor.type;
+        const actorId = this.actingUserId;
+        const requestId = this.request?.id ?? null;
+        const tokenId = this.token?.id ?? null;
+        const insert = this.db.prepare(`INSERT INTO entity_versions (entity_type, entity_id, version, snapshot, actor_type, actor_id, request_id, created_at, token_id)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+        for (const entry of this.touched.values()) {
+            if (!VERSIONED.has(entry.entityType))
+                continue;
+            const previous = this.db
+                .prepare("SELECT MAX(version) AS v FROM entity_versions WHERE entity_type = ? AND entity_id = ?")
+                .get(entry.entityType, entry.entityId);
+            const version = (previous.v ?? 0) + 1;
+            let snapshot = null;
+            if (entry.entityType === "task" && this.store.findTask(entry.entityId)) {
+                this.db.prepare("UPDATE tasks SET version = ? WHERE id = ?").run(version, entry.entityId);
+                snapshot = this.store.taskSnapshot(entry.entityId);
+            }
+            else if (entry.entityType === "idea") {
+                snapshot = this.store.findIdea(entry.entityId);
+            }
+            insert.run(entry.entityType, entry.entityId, version, snapshot === null ? null : JSON.stringify(snapshot), actorType, actorId, requestId, this.now, tokenId);
+        }
+    }
+    /** Une ligne du journal par entité modifiée, avec l'auteur de la mutation. */
+    writeChanges() {
+        const insert = this.db.prepare(`INSERT INTO changes (space_id, user_id, entity_type, entity_id, task_id, at, actor_type, actor_id, request_id)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+        const actorId = this.actingUserId;
+        const requestId = this.request?.id ?? null;
+        for (const entry of this.touched.values()) {
+            insert.run(entry.spaceId, entry.userId, entry.entityType, entry.entityId, entry.taskId, this.now, this.actor.type, actorId, requestId);
+        }
+    }
+}
+/** Champs de `patch` dont la valeur n'est pas `undefined`. */
+function definedFields(patch) {
+    return Object.fromEntries(Object.entries(patch).filter(([, value]) => value !== undefined));
+}