@imenam/mcp-organizer 1.0.2 → 1.0.7

package/dist/shared/schemas/admin-api.schema.d.ts

@@ -0,0 +1,101 @@
+import { z } from "zod";
+/**
+ * API d'administration (`/api/admin/*`), réservée aux administrateurs du
+ * site : tous les comptes avec leurs espaces, et l'autorisation du runner par
+ * espace.
+ */
+export declare const AdminSpaceViewSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    kind: z.ZodEnum<{
+        personal: "personal";
+        shared: "shared";
+    }>;
+    keyPrefix: z.ZodString;
+    runnerAllowed: z.ZodBoolean;
+    members: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        email: z.ZodPipe<z.ZodString, z.ZodEmail>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AdminSpaceView = z.infer<typeof AdminSpaceViewSchema>;
+export declare const AdminUserViewSchema: z.ZodObject<{
+    id: z.ZodString;
+    email: z.ZodPipe<z.ZodString, z.ZodEmail>;
+    displayName: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+        active: "active";
+        disabled: "disabled";
+        invited: "invited";
+    }>;
+    isAdmin: z.ZodBoolean;
+    spaces: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        kind: z.ZodEnum<{
+            personal: "personal";
+            shared: "shared";
+        }>;
+        keyPrefix: z.ZodString;
+        runnerAllowed: z.ZodBoolean;
+        members: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            email: z.ZodPipe<z.ZodString, z.ZodEmail>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AdminUserView = z.infer<typeof AdminUserViewSchema>;
+/** État du runner du site : actif, ou désactivé avec la raison (en français). */
+export declare const RunnerStatusSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    disabledReason: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type RunnerStatus = z.infer<typeof RunnerStatusSchema>;
+/** `GET /admin/spaces` : comptes du plus ancien au plus récent, décompte des espaces autorisés et état du runner. */
+export declare const AdminSpacesResponseSchema: z.ZodObject<{
+    users: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        email: z.ZodPipe<z.ZodString, z.ZodEmail>;
+        displayName: z.ZodNullable<z.ZodString>;
+        status: z.ZodEnum<{
+            active: "active";
+            disabled: "disabled";
+            invited: "invited";
+        }>;
+        isAdmin: z.ZodBoolean;
+        spaces: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            kind: z.ZodEnum<{
+                personal: "personal";
+                shared: "shared";
+            }>;
+            keyPrefix: z.ZodString;
+            runnerAllowed: z.ZodBoolean;
+            members: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                email: z.ZodPipe<z.ZodString, z.ZodEmail>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    allowedCount: z.ZodNumber;
+    spaceCount: z.ZodNumber;
+    runner: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        disabledReason: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type AdminSpacesResponse = z.infer<typeof AdminSpacesResponseSchema>;
+/** `POST /spaces/:spaceId/runner/run` : session lancée pour traiter les demandes en attente. */
+export declare const RunQueueResponseSchema: z.ZodObject<{
+    pendingCount: z.ZodNumber;
+}, z.core.$strip>;
+export type RunQueueResponse = z.infer<typeof RunQueueResponseSchema>;
+/** `PUT /admin/spaces/:spaceId/runner` */
+export declare const SetRunnerAllowedRequestSchema: z.ZodObject<{
+    allowed: z.ZodBoolean;
+}, z.core.$strict>;
+export type SetRunnerAllowedRequest = z.infer<typeof SetRunnerAllowedRequestSchema>;

package/dist/shared/schemas/admin-api.schema.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { SpaceKindSchema, UserStatusSchema } from "./enums.schema.js";
+import { EmailSchema, IdSchema } from "./entities.schema.js";
+/**
+ * API d'administration (`/api/admin/*`), réservée aux administrateurs du
+ * site : tous les comptes avec leurs espaces, et l'autorisation du runner par
+ * espace.
+ */
+export const AdminSpaceViewSchema = z.object({
+    id: IdSchema,
+    name: z.string(),
+    kind: SpaceKindSchema,
+    keyPrefix: z.string(),
+    runnerAllowed: z.boolean(),
+    /** Membres de l'espace, propriétaire compris, dans l'ordre d'arrivée. */
+    members: z.array(z.object({ id: IdSchema, name: z.string(), email: EmailSchema })),
+});
+export const AdminUserViewSchema = z.object({
+    id: IdSchema,
+    email: EmailSchema,
+    displayName: z.string().nullable(),
+    status: UserStatusSchema,
+    isAdmin: z.boolean(),
+    /** Espaces dont le compte est propriétaire : son espace personnel d'abord, puis ses espaces communs par nom. */
+    spaces: z.array(AdminSpaceViewSchema),
+});
+/** État du runner du site : actif, ou désactivé avec la raison (en français). */
+export const RunnerStatusSchema = z.object({ enabled: z.boolean(), disabledReason: z.string().nullable() });
+/** `GET /admin/spaces` : comptes du plus ancien au plus récent, décompte des espaces autorisés et état du runner. */
+export const AdminSpacesResponseSchema = z.object({
+    users: z.array(AdminUserViewSchema),
+    allowedCount: z.number().int().min(0),
+    spaceCount: z.number().int().min(0),
+    runner: RunnerStatusSchema,
+});
+/** `POST /spaces/:spaceId/runner/run` : session lancée pour traiter les demandes en attente. */
+export const RunQueueResponseSchema = z.object({ pendingCount: z.number().int().min(1) });
+/** `PUT /admin/spaces/:spaceId/runner` */
+export const SetRunnerAllowedRequestSchema = z.object({ allowed: z.boolean() }).strict();

package/dist/shared/schemas/agent-api.schema.d.ts

@@ -236,6 +236,8 @@ export declare const RequestListResponseSchema: z.ZodObject<{
         lastUsedAt: z.ZodNullable<z.ZodISODateTime>;
         listening: z.ZodBoolean;
     }, z.core.$strip>>;
+    runnerAllowed: z.ZodBoolean;
+    runnerDisabledReason: z.ZodNullable<z.ZodString>;
 }, z.core.$strip>;
 export type RequestListResponse = z.infer<typeof RequestListResponseSchema>;
 /** Version d'une tâche dans son historique. */

package/dist/shared/schemas/agent-api.schema.js

@@ -80,6 +80,10 @@ export const RequestListResponseSchema = z.object({
      * récemment ; `listening` : un veilleur de notifications de ce jeton est armé.
      */
     agents: z.array(AgentRefSchema.extend({ lastUsedAt: TimestampSchema.nullable(), listening: z.boolean() })),
+    /** Le runner traite les demandes de l'espace (décidé par un administrateur). */
+    runnerAllowed: z.boolean(),
+    /** Raison pour laquelle le runner du site est désactivé (en français), null quand il est actif. */
+    runnerDisabledReason: z.string().nullable(),
 });
 /** Version d'une tâche dans son historique. */
 export const TaskVersionViewSchema = z.object({

package/dist/shared/schemas/agent-tools.schema.d.ts

@@ -361,6 +361,40 @@ export declare const ClaimRequestDataSchema: z.ZodObject<{
         reply: z.ZodNullable<z.ZodString>;
         failureReason: z.ZodNullable<z.ZodString>;
     }, z.core.$strip>;
+    history: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            idea: "idea";
+            idea_promotion: "idea_promotion";
+            message: "message";
+            remark: "remark";
+            test_review: "test_review";
+        }>;
+        status: z.ZodEnum<{
+            cancelled: "cancelled";
+            done: "done";
+            failed: "failed";
+            pending: "pending";
+            processing: "processing";
+        }>;
+        text: z.ZodString;
+        author: z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            email: z.ZodString;
+        }, z.core.$strip>;
+        contextTask: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            key: z.ZodString;
+            title: z.ZodString;
+        }, z.core.$strip>>;
+        contextIdeaId: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodISODateTime;
+        claimedAt: z.ZodNullable<z.ZodISODateTime>;
+        claimedByThisToken: z.ZodBoolean;
+        reply: z.ZodNullable<z.ZodString>;
+        failureReason: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
     space: z.ZodObject<{
         id: z.ZodString;
         name: z.ZodString;
@@ -742,7 +776,11 @@ export declare const AgentWatcherSchema: z.ZodObject<{
     since: z.ZodNullable<z.ZodISODateTime>;
     lastSeen: z.ZodNullable<z.ZodISODateTime>;
 }, z.core.$strip>;
-/** `GET notifications` : jeton et espace de l'agent, demandes en attente et veilleur du jeton. */
+/**
+ * `GET notifications` : jeton et espace de l'agent, demandes en attente,
+ * veilleur du jeton et curseur de départ d'une veille (`since` de la
+ * première attente : seules les demandes passées en attente ensuite sont rendues).
+ */
 export declare const NotificationsDataSchema: z.ZodObject<{
     token: z.ZodObject<{
         id: z.ZodString;
@@ -763,6 +801,7 @@ export declare const NotificationsDataSchema: z.ZodObject<{
         since: z.ZodNullable<z.ZodISODateTime>;
         lastSeen: z.ZodNullable<z.ZodISODateTime>;
     }, z.core.$strip>;
+    cursor: z.ZodISODateTime;
 }, z.core.$strip>;
 /**
  * `GET requests/wait` : demandes passées en attente (vide à l'expiration) et

package/dist/shared/schemas/agent-tools.schema.js

@@ -145,6 +145,8 @@ export const AgentIdeaSchema = z.object({ id: IdSchema, text: z.string(), archiv
 export const ListRequestsDataSchema = z.object({ space: AgentSpaceSchema, requests: z.array(AgentRequestSummarySchema) });
 export const ClaimRequestDataSchema = z.object({
     request: AgentRequestSummarySchema,
+    /** Échanges précédents de l'auteur dans l'espace, du plus ancien au plus récent, pour une demande de type message. */
+    history: z.array(AgentRequestSummarySchema),
     space: AgentSpaceSchema,
     members: z.array(AgentMemberSchema),
     tasks: z.array(AgentTaskSummarySchema),
@@ -179,12 +181,17 @@ export const IdeaDataSchema = z.object({ idea: AgentIdeaSchema });
 export const PromoteIdeaDataSchema = z.object({ idea: AgentIdeaSchema, task: AgentTaskSummarySchema });
 /** Présence d'un veilleur de notifications pour le jeton. */
 export const AgentWatcherSchema = z.object({ armed: z.boolean(), since: TimestampSchema.nullable(), lastSeen: TimestampSchema.nullable() });
-/** `GET notifications` : jeton et espace de l'agent, demandes en attente et veilleur du jeton. */
+/**
+ * `GET notifications` : jeton et espace de l'agent, demandes en attente,
+ * veilleur du jeton et curseur de départ d'une veille (`since` de la
+ * première attente : seules les demandes passées en attente ensuite sont rendues).
+ */
 export const NotificationsDataSchema = z.object({
     token: z.object({ id: IdSchema, name: z.string() }),
     space: AgentSpaceSchema,
     pendingCount: z.number().int().min(0),
     watcher: AgentWatcherSchema,
+    cursor: TimestampSchema,
 });
 /**
  * `GET requests/wait` : demandes passées en attente (vide à l'expiration) et

package/dist/shared/schemas/api.schema.d.ts

@@ -17,6 +17,7 @@ export declare const PublicUserSchema: z.ZodObject<{
         disabled: "disabled";
         invited: "invited";
     }>;
+    isAdmin: z.ZodBoolean;
 }, z.core.$strip>;
 export type PublicUser = z.infer<typeof PublicUserSchema>;
 export declare const LoginRequestSchema: z.ZodObject<{
@@ -34,6 +35,7 @@ export declare const MeResponseSchema: z.ZodObject<{
             disabled: "disabled";
             invited: "invited";
         }>;
+        isAdmin: z.ZodBoolean;
     }, z.core.$strip>;
 }, z.core.$strip>;
 export type MeResponse = z.infer<typeof MeResponseSchema>;

package/dist/shared/schemas/api.schema.js

@@ -15,6 +15,8 @@ export const PublicUserSchema = z.object({
     email: EmailSchema,
     displayName: z.string().nullable(),
     status: UserStatusSchema,
+    /** Administrateur du site : voit la page Administration. */
+    isAdmin: z.boolean(),
 });
 // --- Authentification ---
 export const LoginRequestSchema = z.object({

package/dist/shared/schemas/entities.schema.d.ts

@@ -18,6 +18,7 @@ export declare const UserSchema: z.ZodObject<{
         disabled: "disabled";
         invited: "invited";
     }>;
+    isAdmin: z.ZodBoolean;
     createdAt: z.ZodISODateTime;
 }, z.core.$strip>;
 export type User = z.infer<typeof UserSchema>;
@@ -58,16 +59,40 @@ export declare const AgentTokenSchema: z.ZodObject<{
     lastUsedAt: z.ZodNullable<z.ZodISODateTime>;
     expiresAt: z.ZodNullable<z.ZodISODateTime>;
     revokedAt: z.ZodNullable<z.ZodISODateTime>;
+    isRunner: z.ZodBoolean;
 }, z.core.$strip>;
 export type AgentToken = z.infer<typeof AgentTokenSchema>;
+/** Bornes du nombre d'échanges précédents de l'auteur transmis à l'agent avec un message. */
+export declare const MIN_ASSISTANT_HISTORY = 5;
+export declare const MAX_ASSISTANT_HISTORY = 20;
+export declare const AssistantHistorySchema: z.ZodNumber;
+/** Préférences de notification : assignation et commentaire, dans l'application et par e-mail. */
+export declare const NotificationPreferencesSchema: z.ZodObject<{
+    notifyAssignApp: z.ZodBoolean;
+    notifyAssignEmail: z.ZodBoolean;
+    notifyCommentApp: z.ZodBoolean;
+    notifyCommentEmail: z.ZodBoolean;
+}, z.core.$strip>;
+export type NotificationPreferences = z.infer<typeof NotificationPreferencesSchema>;
 export declare const UserSettingsSchema: z.ZodObject<{
-    userId: z.ZodString;
     notifyAssignApp: z.ZodBoolean;
     notifyAssignEmail: z.ZodBoolean;
     notifyCommentApp: z.ZodBoolean;
     notifyCommentEmail: z.ZodBoolean;
+    userId: z.ZodString;
+    assistantHistory: z.ZodNumber;
 }, z.core.$strip>;
 export type UserSettings = z.infer<typeof UserSettingsSchema>;
+/** Préférences de notification d'un utilisateur propres à un espace ; elles remplacent celles du compte dans cet espace. */
+export declare const SpaceNotificationSettingsSchema: z.ZodObject<{
+    notifyAssignApp: z.ZodBoolean;
+    notifyAssignEmail: z.ZodBoolean;
+    notifyCommentApp: z.ZodBoolean;
+    notifyCommentEmail: z.ZodBoolean;
+    userId: z.ZodString;
+    spaceId: z.ZodString;
+}, z.core.$strip>;
+export type SpaceNotificationSettings = z.infer<typeof SpaceNotificationSettingsSchema>;
 export declare const SpaceSchema: z.ZodObject<{
     id: z.ZodString;
     name: z.ZodString;
@@ -78,6 +103,7 @@ export declare const SpaceSchema: z.ZodObject<{
     ownerId: z.ZodString;
     keyPrefix: z.ZodString;
     nextTaskNumber: z.ZodNumber;
+    runnerAllowed: z.ZodBoolean;
     createdAt: z.ZodISODateTime;
 }, z.core.$strip>;
 export type Space = z.infer<typeof SpaceSchema>;

package/dist/shared/schemas/entities.schema.js

@@ -20,6 +20,8 @@ export const UserSchema = z.object({
     displayName: z.string().min(1).nullable(),
     passwordHash: z.string().min(1).nullable(),
     status: UserStatusSchema,
+    /** Administrateur du site : accède à la page Administration. */
+    isAdmin: z.boolean(),
     createdAt: TimestampSchema,
 });
 export const AccessLinkSchema = z.object({
@@ -55,14 +57,29 @@ export const AgentTokenSchema = z.object({
     lastUsedAt: TimestampSchema.nullable(),
     expiresAt: TimestampSchema.nullable(),
     revokedAt: TimestampSchema.nullable(),
+    /** Jeton du runner de l'espace : absent des Paramètres, sa valeur change à chaque session. */
+    isRunner: z.boolean(),
 });
-export const UserSettingsSchema = z.object({
-    userId: IdSchema,
+/** Bornes du nombre d'échanges précédents de l'auteur transmis à l'agent avec un message. */
+export const MIN_ASSISTANT_HISTORY = 5;
+export const MAX_ASSISTANT_HISTORY = 20;
+export const AssistantHistorySchema = z.number().int().min(MIN_ASSISTANT_HISTORY).max(MAX_ASSISTANT_HISTORY);
+/** Préférences de notification : assignation et commentaire, dans l'application et par e-mail. */
+export const NotificationPreferencesSchema = z.object({
     notifyAssignApp: z.boolean(),
     notifyAssignEmail: z.boolean(),
     notifyCommentApp: z.boolean(),
     notifyCommentEmail: z.boolean(),
 });
+export const UserSettingsSchema = NotificationPreferencesSchema.extend({
+    userId: IdSchema,
+    assistantHistory: AssistantHistorySchema,
+});
+/** Préférences de notification d'un utilisateur propres à un espace ; elles remplacent celles du compte dans cet espace. */
+export const SpaceNotificationSettingsSchema = NotificationPreferencesSchema.extend({
+    userId: IdSchema,
+    spaceId: IdSchema,
+});
 export const SpaceSchema = z.object({
     id: IdSchema,
     name: z.string().trim().min(1),
@@ -70,6 +87,8 @@ export const SpaceSchema = z.object({
     ownerId: IdSchema,
     keyPrefix: KeyPrefixSchema,
     nextTaskNumber: z.number().int().min(1),
+    /** Le runner traite les demandes de l'espace ; décidé par un administrateur. */
+    runnerAllowed: z.boolean(),
     createdAt: TimestampSchema,
 });
 export const MembershipSchema = z.object({

package/dist/shared/schemas/notifications-api.schema.d.ts

@@ -68,6 +68,7 @@ export declare const SettingsResponseSchema: z.ZodObject<{
     notifyAssignEmail: z.ZodBoolean;
     notifyCommentApp: z.ZodBoolean;
     notifyCommentEmail: z.ZodBoolean;
+    assistantHistory: z.ZodNumber;
     email: z.ZodObject<{
         enabled: z.ZodBoolean;
         reason: z.ZodNullable<z.ZodString>;
@@ -83,5 +84,35 @@ export declare const UpdateSettingsRequestSchema: z.ZodObject<{
     notifyAssignEmail: z.ZodOptional<z.ZodBoolean>;
     notifyCommentApp: z.ZodOptional<z.ZodBoolean>;
     notifyCommentEmail: z.ZodOptional<z.ZodBoolean>;
+    assistantHistory: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>;
 export type UpdateSettingsRequest = z.infer<typeof UpdateSettingsRequestSchema>;
+/**
+ * Notifications de l'utilisateur dans un espace : `custom` dit si l'espace a ses
+ * propres préférences ; sinon, les valeurs renvoyées sont celles du compte.
+ */
+export declare const SpaceNotificationSettingsResponseSchema: z.ZodObject<{
+    notifyAssignApp: z.ZodBoolean;
+    notifyAssignEmail: z.ZodBoolean;
+    notifyCommentApp: z.ZodBoolean;
+    notifyCommentEmail: z.ZodBoolean;
+    custom: z.ZodBoolean;
+    email: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        reason: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type SpaceNotificationSettingsResponse = z.infer<typeof SpaceNotificationSettingsResponseSchema>;
+/**
+ * Personnalise les notifications d'un espace (`custom: true`, avec les préférences
+ * à changer ; les autres partent des préférences en vigueur) ou revient à celles
+ * du compte (`custom: false`, sans préférence).
+ */
+export declare const UpdateSpaceNotificationSettingsRequestSchema: z.ZodObject<{
+    notifyAssignApp: z.ZodOptional<z.ZodBoolean>;
+    notifyAssignEmail: z.ZodOptional<z.ZodBoolean>;
+    notifyCommentApp: z.ZodOptional<z.ZodBoolean>;
+    notifyCommentEmail: z.ZodOptional<z.ZodBoolean>;
+    custom: z.ZodBoolean;
+}, z.core.$strict>;
+export type UpdateSpaceNotificationSettingsRequest = z.infer<typeof UpdateSpaceNotificationSettingsRequestSchema>;

package/dist/shared/schemas/notifications-api.schema.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { ActorTypeSchema, NotificationTypeSchema } from "./enums.schema.js";
-import { IdSchema, TimestampSchema } from "./entities.schema.js";
+import { AssistantHistorySchema, IdSchema, NotificationPreferencesSchema, TimestampSchema } from "./entities.schema.js";
 /** Corps des requêtes et des réponses des notifications et des paramètres de la GUI. */
 /** Nombre de notifications renvoyées par défaut, et au plus, par page. */
 export const NOTIFICATIONS_PAGE_SIZE = 20;
@@ -42,6 +42,8 @@ export const SettingsResponseSchema = z.object({
     notifyAssignEmail: z.boolean(),
     notifyCommentApp: z.boolean(),
     notifyCommentEmail: z.boolean(),
+    /** Nombre d'échanges précédents transmis à l'agent avec un message de l'assistant. */
+    assistantHistory: AssistantHistorySchema,
     /** Envoi des e-mails de notification : `reason` dit pourquoi il n'a pas lieu. */
     email: z.object({ enabled: z.boolean(), reason: z.string().nullable() }),
     /** Dictée vocale : `reason` dit pourquoi elle est indisponible. */
@@ -53,6 +55,25 @@ export const UpdateSettingsRequestSchema = z
     notifyAssignEmail: z.boolean().optional(),
     notifyCommentApp: z.boolean().optional(),
     notifyCommentEmail: z.boolean().optional(),
+    assistantHistory: AssistantHistorySchema.optional(),
 })
     .strict()
     .refine((patch) => Object.values(patch).some((value) => value !== undefined), "Aucune modification demandée.");
+/**
+ * Notifications de l'utilisateur dans un espace : `custom` dit si l'espace a ses
+ * propres préférences ; sinon, les valeurs renvoyées sont celles du compte.
+ */
+export const SpaceNotificationSettingsResponseSchema = NotificationPreferencesSchema.extend({
+    custom: z.boolean(),
+    /** Envoi des e-mails de notification : `reason` dit pourquoi il n'a pas lieu. */
+    email: z.object({ enabled: z.boolean(), reason: z.string().nullable() }),
+});
+/**
+ * Personnalise les notifications d'un espace (`custom: true`, avec les préférences
+ * à changer ; les autres partent des préférences en vigueur) ou revient à celles
+ * du compte (`custom: false`, sans préférence).
+ */
+export const UpdateSpaceNotificationSettingsRequestSchema = NotificationPreferencesSchema.partial()
+    .extend({ custom: z.boolean() })
+    .strict()
+    .refine((patch) => patch.custom || [patch.notifyAssignApp, patch.notifyAssignEmail, patch.notifyCommentApp, patch.notifyCommentEmail].every((value) => value === undefined), "Un espace qui suit les préférences du compte n'a pas de préférences propres.");

package/dist/src/agent-api/notifications.js

@@ -21,6 +21,7 @@ export const notificationRoutes = [
                 space: spaceData(agent.space),
                 pendingCount,
                 watcher,
+                cursor: new Date().toISOString(),
             });
         },
     },

package/dist/src/agent-api/requests.js

@@ -1,5 +1,5 @@
 import { ClaimRequestBodySchema, ClaimRequestDataSchema, CompleteRequestBodySchema, FailRequestBodySchema, FinishRequestDataSchema, ListRequestsDataSchema, ListRequestsQuerySchema, } from "../../shared/schemas/agent-tools.schema.js";
-import { agentActor, ideaData, memberData, recentIdeas, requestContext, requestData, requestLine, requestOfSpace, spaceData, treeData } from "../core/agent.js";
+import { agentActor, ideaData, memberData, recentIdeas, requestContext, requestData, requestHistory, requestLine, requestOfSpace, spaceData, treeData } from "../core/agent.js";
 import { parseInput, respond } from "./types.js";
 /** Demandes de l'espace du jeton : liste, prise, fin (réussie ou en échec). */
 export const requestRoutes = [
@@ -28,6 +28,7 @@ export const requestRoutes = [
             const request = store.mutate(agentActor(agent, params.requestId), (tx) => tx.claimAgentRequest());
             return respond(ClaimRequestDataSchema, requestContext(store, agent, request), {
                 request: requestData(store, agent, request),
+                history: requestHistory(store, request).map((previous) => requestData(store, agent, previous)),
                 space: spaceData(agent.space),
                 members: memberData(store, agent.space),
                 tasks: treeData(store, agent.space),

package/dist/src/cli/set-admin.d.ts

@@ -0,0 +1 @@
+export declare function runSetAdmin(argv: string[], dataDir: string): Promise<number>;

package/dist/src/cli/set-admin.js

@@ -0,0 +1,45 @@
+import { setAdmin } from "../core/admin.js";
+import { Store } from "../core/store.js";
+/**
+ * Commande `--set-admin <email> [--revoke]` : accorde le rôle
+ * d'administrateur du site à un compte actif, ou le lui retire avec
+ * `--revoke`. Le dernier administrateur ne peut pas perdre son rôle.
+ */
+const USAGE = "Usage : mcp-organizer --set-admin <email> [--revoke]";
+class UsageError extends Error {
+}
+function parseArgs(argv) {
+    const rest = argv.slice(argv.indexOf("--set-admin") + 1);
+    const unknown = rest.filter((arg) => arg.startsWith("-") && arg !== "--revoke");
+    if (unknown.length > 0)
+        throw new UsageError(`Option inconnue : ${unknown.join(", ")}.`);
+    const positional = rest.filter((arg) => !arg.startsWith("-"));
+    if (positional.length === 0)
+        throw new UsageError("--set-admin attend l'adresse e-mail du compte.");
+    if (positional.length > 1)
+        throw new UsageError(`Une seule adresse à la fois (reçu : ${positional.join(", ")}).`);
+    return { email: positional[0], revoke: rest.includes("--revoke") };
+}
+export async function runSetAdmin(argv, dataDir) {
+    let args;
+    try {
+        args = parseArgs(argv);
+    }
+    catch (err) {
+        process.stderr.write(`${err?.message ?? err}\n${USAGE}\n`);
+        return 1;
+    }
+    const store = Store.open(dataDir);
+    try {
+        const user = setAdmin(store, args.email, !args.revoke);
+        process.stdout.write(args.revoke ? `${user.email} n'est plus administrateur du site.\n` : `${user.email} (${user.displayName}) est administrateur du site.\n`);
+        return 0;
+    }
+    catch (err) {
+        process.stderr.write(`${err?.message ?? err}\n`);
+        return 1;
+    }
+    finally {
+        store.close();
+    }
+}

package/dist/src/cli/watch.d.ts

@@ -1,4 +1 @@
-import { type AgentRequestSummary } from "../../shared/schemas/agent-tools.schema.js";
-/** Ligne d'une demande : une seule ligne, lisible telle quelle dans la notification. */
-export declare function formatRequestEvent(request: AgentRequestSummary): string;
 export declare function runWatchMode(tokenId: string | undefined): Promise<number>;

package/dist/src/cli/watch.js

@@ -1,6 +1,7 @@
 import { MAX_WAIT_SECONDS } from "../../shared/schemas/agent-tools.schema.js";
 import { ConfigError } from "../core/errors.js";
 import { OrganizerSiteClient, SiteError } from "../mcp/client.js";
+import { formatRequestEvent } from "../mcp/notifications.js";
 import { readHandoff } from "../mcp/watch-handoff.js";
 /**
  * Mode veilleur (`--watch <identifiant du jeton>`).
@@ -15,15 +16,6 @@ import { readHandoff } from "../mcp/watch-handoff.js";
  */
 const BACKOFF_MIN_MS = 1_000;
 const BACKOFF_MAX_MS = 30_000;
-/** Longueur maximale de l'extrait du texte de la demande. */
-const EXCERPT_LENGTH = 120;
-/** Ligne d'une demande : une seule ligne, lisible telle quelle dans la notification. */
-export function formatRequestEvent(request) {
-    const text = request.text.replace(/\s+/g, " ").trim();
-    const excerpt = text.length > EXCERPT_LENGTH ? `${text.slice(0, EXCERPT_LENGTH - 1)}…` : text;
-    const context = request.contextTask ? ` · ${request.contextTask.key}` : "";
-    return `[organizer] ${request.kind} · ${request.author.name} — "${excerpt}"${context} (${request.id})`;
-}
 /** Refus définitif du site : un nouvel essai donnerait la même réponse. */
 function isRefusal(error) {
     return error instanceof SiteError && error.status !== undefined && error.status >= 400 && error.status < 500 && error.status !== 408 && error.status !== 429;

package/dist/src/core/accounts.js

@@ -147,7 +147,8 @@ export async function setAccount(store, input) {
             tx.discardUnusedAccessLinks(user.id);
             return { created: false, user };
         }
-        const created = tx.createUser({ id: userId, email: normalized, displayName: name, passwordHash, status: "active" });
+        // Le premier compte du site en est l'administrateur.
+        const created = tx.createUser({ id: userId, email: normalized, displayName: name, passwordHash, status: "active", isAdmin: tx.store.countUsers() === 0 });
         ensurePersonalSpace(tx, created.id);
         return { created: true, user: created };
     });

package/dist/src/core/admin.d.ts

@@ -0,0 +1,24 @@
+import type { AdminSpaceView, AdminSpacesResponse, RunQueueResponse, RunnerStatus } from "../../shared/schemas/admin-api.schema.js";
+import type { User } from "../../shared/schemas/entities.schema.js";
+import type { Store } from "./store.js";
+/**
+ * Administration du site : rôle d'administrateur des comptes, et
+ * autorisation du runner par espace. Seul un administrateur voit tous les
+ * comptes et tous les espaces, et décide des espaces où le runner travaille.
+ */
+/** L'utilisateur est administrateur ; sinon, refus. */
+export declare function requireAdmin(store: Store, userId: string): User;
+/** Tous les comptes, chacun avec les espaces dont il est propriétaire, et l'état du runner. */
+export declare function listAdminSpaces(store: Store, userId: string, runner: RunnerStatus): AdminSpacesResponse;
+/** Autorise ou interdit le runner sur un espace. */
+export declare function setRunnerAllowed(store: Store, userId: string, spaceId: string, allowed: boolean): AdminSpaceView;
+/**
+ * Fait traiter une fois la file d'un espace par le runner, qu'il y soit
+ * autorisé ou non ; refus quand aucune demande n'y attend.
+ */
+export declare function processQueueNow(store: Store, userId: string, spaceId: string, runNow: (spaceId: string) => void): RunQueueResponse;
+/**
+ * Accorde ou retire le rôle d'administrateur au compte actif `email`. Le
+ * dernier administrateur garde son rôle : le site n'en reste jamais dépourvu.
+ */
+export declare function setAdmin(store: Store, email: string, isAdmin: boolean): User;