@imenam/mcp-organizer 0.0.0-stage → 1.0.2

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

@@ -0,0 +1,198 @@
+import { z } from "zod";
+import { MemberRoleSchema, REQUEST_STATUSES, RequestKindSchema, RequestStatusSchema, SpaceKindSchema, TASK_PRIORITIES, TASK_STATUSES, TASK_TYPES, TaskPrioritySchema, TaskStatusSchema, TaskTypeSchema, TestResultValueSchema, } from "./enums.schema.js";
+import { IdSchema, TimestampSchema } from "./entities.schema.js";
+import { MAX_TAG_LENGTH, MAX_TASK_TITLE_LENGTH } from "./tasks-api.schema.js";
+/**
+ * API des agents (`/api/agent/*`), partagée par le site et le mode MCP :
+ * paramètres et corps des requêtes (noms des arguments des outils), et
+ * réponses. Chaque réponse porte `text`, le résultat rédigé pour l'agent, et
+ * `data`, les mêmes informations structurées. Une erreur est `{ error }`.
+ */
+export const MAX_REQUEST_LIST_LIMIT = 100;
+export const MAX_SEARCH_LIMIT = 100;
+export const MAX_REPLY_LENGTH = 5_000;
+export const MAX_REASON_LENGTH = 2_000;
+export const MAX_COMMENT_LENGTH = 10_000;
+export const MAX_IDEA_LENGTH = 5_000;
+export const MAX_CHECKLIST_ITEM_LENGTH = 500;
+export const MAX_CHECKLIST_OPERATIONS = 50;
+const RequestIdSchema = z.string().min(1);
+const RefSchema = z.string().min(1);
+// --- Paramètres et corps -----------------------------------------------------------
+/** `GET requests` : statut à lister (`all` : tous) et nombre maximal. */
+export const ListRequestsQuerySchema = z
+    .object({
+    status: z.enum([...REQUEST_STATUSES, "all"]).default("pending"),
+    limit: z.coerce.number().int().min(1).max(MAX_REQUEST_LIST_LIMIT).default(20),
+})
+    .strict();
+/** Durée maximale d'une attente longue de `GET requests/wait`, en secondes. */
+export const MAX_WAIT_SECONDS = 50;
+/**
+ * `GET requests/wait` : durée de l'attente ; `since`, curseur rendu par
+ * l'attente précédente (les demandes passées en attente depuis sont rendues
+ * aussitôt) ; `watcher=true` pour un veilleur de notifications.
+ */
+export const WaitRequestsQuerySchema = z
+    .object({
+    timeout_seconds: z.coerce.number().int().min(1).max(MAX_WAIT_SECONDS).default(30),
+    since: TimestampSchema.optional(),
+    watcher: z.enum(["true"]).optional(),
+})
+    .strict();
+/** `POST requests/:id/claim` : sans corps. */
+export const ClaimRequestBodySchema = z.object({}).strict();
+export const CompleteRequestBodySchema = z.object({ reply: z.string().max(MAX_REPLY_LENGTH) }).strict();
+export const FailRequestBodySchema = z.object({ reason: z.string().max(MAX_REASON_LENGTH) }).strict();
+/** `GET tasks` : recherche par mots et filtres. */
+export const SearchTasksQuerySchema = z
+    .object({
+    query: z.string().optional(),
+    status: z.enum(TASK_STATUSES).optional(),
+    priority: z.enum(TASK_PRIORITIES).optional(),
+    type: z.enum(TASK_TYPES).optional(),
+    assignee: z.string().min(1).optional(),
+    limit: z.coerce.number().int().min(1).max(MAX_SEARCH_LIMIT).default(30),
+})
+    .strict();
+/** `GET tasks/:ref` et `GET context` : sans paramètre. */
+export const NoQuerySchema = z.object({}).strict();
+export const CreateTaskBodySchema = z
+    .object({
+    request_id: RequestIdSchema,
+    title: z.string().max(MAX_TASK_TITLE_LENGTH),
+    description: z.string().optional(),
+    type: z.enum(TASK_TYPES).optional(),
+    priority: z.enum(TASK_PRIORITIES).optional(),
+    status: z.enum(TASK_STATUSES).optional(),
+    parent: RefSchema.optional(),
+})
+    .strict();
+export const UpdateTaskBodySchema = z
+    .object({
+    request_id: RequestIdSchema,
+    title: z.string().max(MAX_TASK_TITLE_LENGTH).optional(),
+    description: z.string().optional(),
+    status: z.enum(TASK_STATUSES).optional(),
+    priority: z.enum(TASK_PRIORITIES).optional(),
+    type: z.enum(TASK_TYPES).optional(),
+    parent: RefSchema.nullable().optional(),
+    after_task: RefSchema.nullable().optional(),
+    tested_task_id: RefSchema.nullable().optional(),
+})
+    .strict();
+export const SetAssigneesBodySchema = z.object({ request_id: RequestIdSchema, assignees: z.array(z.string().min(1)) }).strict();
+export const SetTagsBodySchema = z.object({ request_id: RequestIdSchema, tags: z.array(z.string().trim().min(1).max(MAX_TAG_LENGTH)) }).strict();
+const ChecklistTextSchema = z.string().trim().min(1).max(MAX_CHECKLIST_ITEM_LENGTH);
+export const ChecklistOperationSchema = z.discriminatedUnion("action", [
+    z.object({ action: z.literal("add"), text: ChecklistTextSchema }).strict(),
+    z.object({ action: z.literal("update"), item_id: z.string().min(1), text: ChecklistTextSchema.optional(), done: z.boolean().optional() }).strict(),
+    z.object({ action: z.literal("delete"), item_id: z.string().min(1) }).strict(),
+]);
+export const EditChecklistBodySchema = z
+    .object({ request_id: RequestIdSchema, operations: z.array(ChecklistOperationSchema).min(1).max(MAX_CHECKLIST_OPERATIONS) })
+    .strict();
+export const AddCommentBodySchema = z.object({ request_id: RequestIdSchema, body: z.string().max(MAX_COMMENT_LENGTH) }).strict();
+export const CreateIdeaBodySchema = z.object({ request_id: RequestIdSchema, text: z.string().max(MAX_IDEA_LENGTH) }).strict();
+export const UpdateIdeaBodySchema = z
+    .object({ request_id: RequestIdSchema, text: z.string().max(MAX_IDEA_LENGTH).optional(), archived: z.boolean().optional() })
+    .strict();
+export const PromoteIdeaBodySchema = z
+    .object({
+    request_id: RequestIdSchema,
+    title: z.string().max(MAX_TASK_TITLE_LENGTH),
+    description: z.string().optional(),
+    type: z.enum(TASK_TYPES).optional(),
+    priority: z.enum(TASK_PRIORITIES).optional(),
+    parent: RefSchema.optional(),
+})
+    .strict();
+// --- Réponses ---------------------------------------------------------------------
+/** Enveloppe de toute réponse réussie : texte pour l'agent et données structurées. */
+export const AgentEnvelopeSchema = z.object({ text: z.string(), data: z.unknown() });
+/** Réponse d'erreur : le message dit à l'agent quoi faire. */
+export const AgentErrorSchema = z.object({ error: z.string() });
+export const AgentSpaceSchema = z.object({ id: IdSchema, name: z.string(), kind: SpaceKindSchema, keyPrefix: z.string() });
+export const AgentMemberSchema = z.object({ id: IdSchema, name: z.string(), email: z.string(), role: MemberRoleSchema });
+export const AgentTaskSummarySchema = z.object({
+    id: IdSchema,
+    key: z.string(),
+    title: z.string(),
+    type: TaskTypeSchema,
+    status: TaskStatusSchema,
+    priority: TaskPrioritySchema,
+    depth: z.number().int().min(0),
+    parentKey: z.string().nullable(),
+    assigneeIds: z.array(IdSchema),
+    tags: z.array(z.string()),
+});
+export const AgentRequestSummarySchema = z.object({
+    id: IdSchema,
+    kind: RequestKindSchema,
+    status: RequestStatusSchema,
+    text: z.string(),
+    author: z.object({ id: IdSchema, name: z.string(), email: z.string() }),
+    contextTask: z.object({ id: IdSchema, key: z.string(), title: z.string() }).nullable(),
+    contextIdeaId: IdSchema.nullable(),
+    createdAt: TimestampSchema,
+    claimedAt: TimestampSchema.nullable(),
+    /** Vrai si la demande est prise par le jeton qui appelle. */
+    claimedByThisToken: z.boolean(),
+    reply: z.string().nullable(),
+    failureReason: z.string().nullable(),
+});
+export const AgentIdeaSchema = z.object({ id: IdSchema, text: z.string(), archived: z.boolean(), promotedTaskKey: z.string().nullable(), createdAt: TimestampSchema });
+export const ListRequestsDataSchema = z.object({ space: AgentSpaceSchema, requests: z.array(AgentRequestSummarySchema) });
+export const ClaimRequestDataSchema = z.object({
+    request: AgentRequestSummarySchema,
+    space: AgentSpaceSchema,
+    members: z.array(AgentMemberSchema),
+    tasks: z.array(AgentTaskSummarySchema),
+    ideas: z.array(AgentIdeaSchema),
+});
+export const FinishRequestDataSchema = z.object({ request: AgentRequestSummarySchema, actionCount: z.number().int().min(0) });
+export const ContextDataSchema = z.object({
+    space: AgentSpaceSchema,
+    members: z.array(AgentMemberSchema),
+    tasks: z.array(AgentTaskSummarySchema),
+    ideas: z.array(AgentIdeaSchema),
+});
+export const TaskDataSchema = z.object({ task: AgentTaskSummarySchema });
+export const TaskDetailDataSchema = z.object({
+    task: AgentTaskSummarySchema,
+    description: z.string(),
+    testedTaskKey: z.string().nullable(),
+    checklist: z.array(z.object({ id: IdSchema, text: z.string(), done: z.boolean() })),
+    checkpoints: z.array(z.object({ id: IdSchema, text: z.string(), result: TestResultValueSchema })),
+    children: z.array(AgentTaskSummarySchema),
+    comments: z.array(z.object({ id: IdSchema, authorName: z.string(), byAgent: z.boolean(), body: z.string(), createdAt: TimestampSchema })),
+    attachments: z.array(z.string()),
+});
+export const SearchTasksDataSchema = z.object({ tasks: z.array(AgentTaskSummarySchema), total: z.number().int().min(0) });
+export const ChecklistDataSchema = z.object({
+    task: AgentTaskSummarySchema,
+    /** Éléments de la checklist (tâche standard, `done` renseigné) ou points de vérification (tâche de test, `done` nul). */
+    items: z.array(z.object({ id: IdSchema, text: z.string(), done: z.boolean().nullable() })),
+});
+export const CommentDataSchema = z.object({ task: AgentTaskSummarySchema, commentId: IdSchema });
+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. */
+export const NotificationsDataSchema = z.object({
+    token: z.object({ id: IdSchema, name: z.string() }),
+    space: AgentSpaceSchema,
+    pendingCount: z.number().int().min(0),
+    watcher: AgentWatcherSchema,
+});
+/**
+ * `GET requests/wait` : demandes passées en attente (vide à l'expiration) et
+ * curseur à repasser en `since` à l'attente suivante.
+ */
+export const WaitRequestsDataSchema = z.object({
+    space: AgentSpaceSchema,
+    requests: z.array(AgentRequestSummarySchema),
+    cursor: TimestampSchema,
+    timedOut: z.boolean(),
+});

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

@@ -0,0 +1,249 @@
+import { z } from "zod";
+/** Corps des requêtes et des réponses de l'API `/api/*` de la GUI. */
+/** Longueur minimale d'un mot de passe. */
+export declare const MIN_PASSWORD_LENGTH = 8;
+/** Longueur maximale d'un nom affiché ou d'un nom d'espace. */
+export declare const MAX_NAME_LENGTH = 80;
+export declare const PasswordSchema: z.ZodString;
+export declare const DisplayNameSchema: z.ZodString;
+export declare const SpaceNameSchema: z.ZodString;
+/** Utilisateur tel que la GUI le voit : jamais de hash de mot de passe. */
+export declare const PublicUserSchema: 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";
+    }>;
+}, z.core.$strip>;
+export type PublicUser = z.infer<typeof PublicUserSchema>;
+export declare const LoginRequestSchema: z.ZodObject<{
+    email: z.ZodString;
+    password: z.ZodString;
+}, z.core.$strip>;
+export type LoginRequest = z.infer<typeof LoginRequestSchema>;
+export declare const MeResponseSchema: z.ZodObject<{
+    user: 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";
+        }>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type MeResponse = z.infer<typeof MeResponseSchema>;
+/** Lien d'accès valide : compte concerné et objet du lien. */
+export declare const AccessLinkInfoSchema: z.ZodObject<{
+    email: z.ZodPipe<z.ZodString, z.ZodEmail>;
+    purpose: z.ZodEnum<{
+        invite: "invite";
+        reset: "reset";
+    }>;
+    displayName: z.ZodNullable<z.ZodString>;
+    expiresAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export type AccessLinkInfo = z.infer<typeof AccessLinkInfoSchema>;
+export declare const ActivateRequestSchema: z.ZodObject<{
+    displayName: z.ZodString;
+    password: z.ZodString;
+}, z.core.$strip>;
+export type ActivateRequest = z.infer<typeof ActivateRequestSchema>;
+/** Profil : nouveau nom affiché. */
+export declare const UpdateProfileRequestSchema: z.ZodObject<{
+    displayName: z.ZodString;
+}, z.core.$strip>;
+export type UpdateProfileRequest = z.infer<typeof UpdateProfileRequestSchema>;
+/** Profil : changement de mot de passe, avec l'ancien. */
+export declare const ChangePasswordRequestSchema: z.ZodObject<{
+    currentPassword: z.ZodString;
+    newPassword: z.ZodString;
+}, z.core.$strip>;
+export type ChangePasswordRequest = z.infer<typeof ChangePasswordRequestSchema>;
+export declare const OkResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+}, z.core.$strip>;
+export type OkResponse = z.infer<typeof OkResponseSchema>;
+/** Espace vu par un de ses membres, avec son rôle. */
+export declare const SpaceSummarySchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    kind: z.ZodEnum<{
+        personal: "personal";
+        shared: "shared";
+    }>;
+    keyPrefix: z.ZodString;
+    ownerId: z.ZodString;
+    role: z.ZodEnum<{
+        member: "member";
+        owner: "owner";
+    }>;
+}, z.core.$strip>;
+export type SpaceSummary = z.infer<typeof SpaceSummarySchema>;
+export declare const SpaceListResponseSchema: z.ZodObject<{
+    spaces: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        kind: z.ZodEnum<{
+            personal: "personal";
+            shared: "shared";
+        }>;
+        keyPrefix: z.ZodString;
+        ownerId: z.ZodString;
+        role: z.ZodEnum<{
+            member: "member";
+            owner: "owner";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SpaceListResponse = z.infer<typeof SpaceListResponseSchema>;
+export declare const CreateSpaceRequestSchema: z.ZodObject<{
+    name: z.ZodString;
+    keyPrefix: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export type CreateSpaceRequest = z.infer<typeof CreateSpaceRequestSchema>;
+export declare const RenameSpaceRequestSchema: z.ZodObject<{
+    name: z.ZodString;
+}, z.core.$strip>;
+export type RenameSpaceRequest = z.infer<typeof RenameSpaceRequestSchema>;
+export declare const MemberViewSchema: z.ZodObject<{
+    userId: z.ZodString;
+    email: z.ZodPipe<z.ZodString, z.ZodEmail>;
+    displayName: z.ZodNullable<z.ZodString>;
+    role: z.ZodEnum<{
+        member: "member";
+        owner: "owner";
+    }>;
+}, z.core.$strip>;
+export type MemberView = z.infer<typeof MemberViewSchema>;
+export declare const PendingInvitationViewSchema: z.ZodObject<{
+    id: z.ZodString;
+    email: z.ZodPipe<z.ZodString, z.ZodEmail>;
+    createdAt: z.ZodISODateTime;
+    expiresAt: z.ZodISODateTime;
+    expired: z.ZodBoolean;
+}, z.core.$strip>;
+export type PendingInvitationView = z.infer<typeof PendingInvitationViewSchema>;
+export declare const MembersResponseSchema: z.ZodObject<{
+    space: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        kind: z.ZodEnum<{
+            personal: "personal";
+            shared: "shared";
+        }>;
+        keyPrefix: z.ZodString;
+        ownerId: z.ZodString;
+        role: z.ZodEnum<{
+            member: "member";
+            owner: "owner";
+        }>;
+    }, z.core.$strip>;
+    members: z.ZodArray<z.ZodObject<{
+        userId: z.ZodString;
+        email: z.ZodPipe<z.ZodString, z.ZodEmail>;
+        displayName: z.ZodNullable<z.ZodString>;
+        role: z.ZodEnum<{
+            member: "member";
+            owner: "owner";
+        }>;
+    }, z.core.$strip>>;
+    invitations: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        email: z.ZodPipe<z.ZodString, z.ZodEmail>;
+        createdAt: z.ZodISODateTime;
+        expiresAt: z.ZodISODateTime;
+        expired: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type MembersResponse = z.infer<typeof MembersResponseSchema>;
+export declare const InviteRequestSchema: z.ZodObject<{
+    email: z.ZodPipe<z.ZodString, z.ZodEmail>;
+}, z.core.$strip>;
+export type InviteRequest = z.infer<typeof InviteRequestSchema>;
+/** Lien d'activation d'un compte invité. `path` est relatif à la GUI, qui en forme l'adresse complète. */
+export declare const InvitationLinkSchema: z.ZodObject<{
+    path: z.ZodString;
+    expiresAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export type InvitationLink = z.infer<typeof InvitationLinkSchema>;
+/** Envoi de l'e-mail d'invitation : `reason` explique un envoi qui n'a pas eu lieu. */
+export declare const EmailOutcomeSchema: z.ZodObject<{
+    emailSent: z.ZodBoolean;
+    reason: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type EmailOutcome = z.infer<typeof EmailOutcomeSchema>;
+export declare const InviteResponseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    outcome: z.ZodLiteral<"member_added">;
+    member: z.ZodObject<{
+        userId: z.ZodString;
+        email: z.ZodPipe<z.ZodString, z.ZodEmail>;
+        displayName: z.ZodNullable<z.ZodString>;
+        role: z.ZodEnum<{
+            member: "member";
+            owner: "owner";
+        }>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    outcome: z.ZodLiteral<"invited">;
+    invitation: z.ZodObject<{
+        id: z.ZodString;
+        email: z.ZodPipe<z.ZodString, z.ZodEmail>;
+        createdAt: z.ZodISODateTime;
+        expiresAt: z.ZodISODateTime;
+        expired: z.ZodBoolean;
+    }, z.core.$strip>;
+    link: z.ZodObject<{
+        path: z.ZodString;
+        expiresAt: z.ZodISODateTime;
+    }, z.core.$strip>;
+    email: z.ZodObject<{
+        emailSent: z.ZodBoolean;
+        reason: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>], "outcome">;
+export type InviteResponse = z.infer<typeof InviteResponseSchema>;
+/** Invitation renvoyée : nouvelle échéance, et nouveau lien d'activation pour un compte encore à activer (null pour un compte actif). */
+export declare const ResendInvitationResponseSchema: z.ZodObject<{
+    invitation: z.ZodObject<{
+        id: z.ZodString;
+        email: z.ZodPipe<z.ZodString, z.ZodEmail>;
+        createdAt: z.ZodISODateTime;
+        expiresAt: z.ZodISODateTime;
+        expired: z.ZodBoolean;
+    }, z.core.$strip>;
+    link: z.ZodNullable<z.ZodObject<{
+        path: z.ZodString;
+        expiresAt: z.ZodISODateTime;
+    }, z.core.$strip>>;
+    email: z.ZodObject<{
+        emailSent: z.ZodBoolean;
+        reason: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ResendInvitationResponse = z.infer<typeof ResendInvitationResponseSchema>;
+/** Invitation en attente reçue par l'utilisateur connecté. */
+export declare const ReceivedInvitationViewSchema: z.ZodObject<{
+    id: z.ZodString;
+    spaceId: z.ZodString;
+    spaceName: z.ZodString;
+    invitedByName: z.ZodString;
+    createdAt: z.ZodISODateTime;
+    expiresAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export type ReceivedInvitationView = z.infer<typeof ReceivedInvitationViewSchema>;
+export declare const ReceivedInvitationsResponseSchema: z.ZodObject<{
+    invitations: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        spaceId: z.ZodString;
+        spaceName: z.ZodString;
+        invitedByName: z.ZodString;
+        createdAt: z.ZodISODateTime;
+        expiresAt: z.ZodISODateTime;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ReceivedInvitationsResponse = z.infer<typeof ReceivedInvitationsResponseSchema>;

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

@@ -0,0 +1,116 @@
+import { z } from "zod";
+import { AccessLinkPurposeSchema, MemberRoleSchema, SpaceKindSchema, UserStatusSchema } from "./enums.schema.js";
+import { EmailSchema, IdSchema, KeyPrefixSchema, TimestampSchema } from "./entities.schema.js";
+/** Corps des requêtes et des réponses de l'API `/api/*` de la GUI. */
+/** Longueur minimale d'un mot de passe. */
+export const MIN_PASSWORD_LENGTH = 8;
+/** Longueur maximale d'un nom affiché ou d'un nom d'espace. */
+export const MAX_NAME_LENGTH = 80;
+export const PasswordSchema = z.string().min(MIN_PASSWORD_LENGTH, `Le mot de passe doit faire au moins ${MIN_PASSWORD_LENGTH} caractères.`);
+export const DisplayNameSchema = z.string().trim().min(1, "Le nom affiché est requis.").max(MAX_NAME_LENGTH);
+export const SpaceNameSchema = z.string().trim().min(1, "Le nom de l'espace est requis.").max(MAX_NAME_LENGTH);
+/** Utilisateur tel que la GUI le voit : jamais de hash de mot de passe. */
+export const PublicUserSchema = z.object({
+    id: IdSchema,
+    email: EmailSchema,
+    displayName: z.string().nullable(),
+    status: UserStatusSchema,
+});
+// --- Authentification ---
+export const LoginRequestSchema = z.object({
+    email: z.string().trim().min(1, "L'adresse e-mail est requise."),
+    password: z.string().min(1, "Le mot de passe est requis."),
+});
+export const MeResponseSchema = z.object({ user: PublicUserSchema });
+/** Lien d'accès valide : compte concerné et objet du lien. */
+export const AccessLinkInfoSchema = z.object({
+    email: EmailSchema,
+    purpose: AccessLinkPurposeSchema,
+    displayName: z.string().nullable(),
+    expiresAt: TimestampSchema,
+});
+export const ActivateRequestSchema = z.object({
+    displayName: DisplayNameSchema,
+    password: PasswordSchema,
+});
+/** Profil : nouveau nom affiché. */
+export const UpdateProfileRequestSchema = z.object({ displayName: DisplayNameSchema });
+/** Profil : changement de mot de passe, avec l'ancien. */
+export const ChangePasswordRequestSchema = z.object({
+    currentPassword: z.string().min(1, "Le mot de passe actuel est requis."),
+    newPassword: PasswordSchema,
+});
+export const OkResponseSchema = z.object({ ok: z.literal(true) });
+// --- Espaces ---
+/** Espace vu par un de ses membres, avec son rôle. */
+export const SpaceSummarySchema = z.object({
+    id: IdSchema,
+    name: z.string(),
+    kind: SpaceKindSchema,
+    keyPrefix: KeyPrefixSchema,
+    ownerId: IdSchema,
+    role: MemberRoleSchema,
+});
+export const SpaceListResponseSchema = z.object({ spaces: z.array(SpaceSummarySchema) });
+export const CreateSpaceRequestSchema = z.object({
+    name: SpaceNameSchema,
+    /** Préfixe des numéros de tâche ; dérivé du nom s'il est omis. */
+    keyPrefix: z.string().trim().toUpperCase().pipe(KeyPrefixSchema).optional(),
+});
+export const RenameSpaceRequestSchema = z.object({ name: SpaceNameSchema });
+export const MemberViewSchema = z.object({
+    userId: IdSchema,
+    email: EmailSchema,
+    displayName: z.string().nullable(),
+    role: MemberRoleSchema,
+});
+export const PendingInvitationViewSchema = z.object({
+    id: IdSchema,
+    email: EmailSchema,
+    createdAt: TimestampSchema,
+    expiresAt: TimestampSchema,
+    expired: z.boolean(),
+});
+export const MembersResponseSchema = z.object({
+    space: SpaceSummarySchema,
+    members: z.array(MemberViewSchema),
+    invitations: z.array(PendingInvitationViewSchema),
+});
+export const InviteRequestSchema = z.object({
+    email: z.string().trim().toLowerCase().min(1, "L'adresse e-mail est requise.").pipe(z.email("Adresse e-mail invalide.")),
+});
+/** Lien d'activation d'un compte invité. `path` est relatif à la GUI, qui en forme l'adresse complète. */
+export const InvitationLinkSchema = z.object({
+    path: z.string().min(1),
+    expiresAt: TimestampSchema,
+});
+/** Envoi de l'e-mail d'invitation : `reason` explique un envoi qui n'a pas eu lieu. */
+export const EmailOutcomeSchema = z.object({
+    emailSent: z.boolean(),
+    reason: z.string().nullable(),
+});
+export const InviteResponseSchema = z.discriminatedUnion("outcome", [
+    z.object({ outcome: z.literal("member_added"), member: MemberViewSchema }),
+    z.object({
+        outcome: z.literal("invited"),
+        invitation: PendingInvitationViewSchema,
+        link: InvitationLinkSchema,
+        email: EmailOutcomeSchema,
+    }),
+]);
+/** Invitation renvoyée : nouvelle échéance, et nouveau lien d'activation pour un compte encore à activer (null pour un compte actif). */
+export const ResendInvitationResponseSchema = z.object({
+    invitation: PendingInvitationViewSchema,
+    link: InvitationLinkSchema.nullable(),
+    email: EmailOutcomeSchema,
+});
+/** Invitation en attente reçue par l'utilisateur connecté. */
+export const ReceivedInvitationViewSchema = z.object({
+    id: IdSchema,
+    spaceId: IdSchema,
+    spaceName: z.string(),
+    invitedByName: z.string(),
+    createdAt: TimestampSchema,
+    expiresAt: TimestampSchema,
+});
+export const ReceivedInvitationsResponseSchema = z.object({ invitations: z.array(ReceivedInvitationViewSchema) });