@imenam/mcp-organizer 0.0.0-stage → 1.0.1

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

@@ -0,0 +1,225 @@
+import { z } from "zod";
+import { RequestStatusSchema, TaskPrioritySchema, TaskStatusSchema, TaskTypeSchema, TestResultValueSchema } from "./enums.schema.js";
+import { ChangeSchema, EmailSchema, IdSchema, PositionSchema, TimestampSchema } from "./entities.schema.js";
+/** Corps des requêtes et des réponses de l'API des tâches de la GUI. */
+/** Taille maximale d'une pièce jointe : 20 Mo. */
+export const MAX_ATTACHMENT_BYTES = 20 * 1024 * 1024;
+export const MAX_TASK_TITLE_LENGTH = 200;
+export const MAX_TAG_LENGTH = 40;
+export const TaskTitleSchema = z.string().trim().min(1, "Le titre est requis.").max(MAX_TASK_TITLE_LENGTH, `Le titre dépasse ${MAX_TASK_TITLE_LENGTH} caractères.`);
+export const TagNameSchema = z.string().trim().min(1, "Un tag ne peut pas être vide.").max(MAX_TAG_LENGTH, `Un tag dépasse ${MAX_TAG_LENGTH} caractères.`);
+/** Membre d'un espace tel que l'affichent les avatars et les menus. */
+export const MemberRefSchema = z.object({
+    userId: IdSchema,
+    displayName: z.string().nullable(),
+    email: EmailSchema,
+});
+export const TagViewSchema = z.object({ id: IdSchema, name: z.string() });
+/** Avancement des sous-tâches directes : terminées / total. */
+export const ProgressSchema = z.object({ done: z.number().int().min(0), total: z.number().int().min(0) });
+/** Bilan d'une tâche de test : points par résultat combiné de ses testeurs (voir `shared/logic/test-summary.ts`). */
+export const TestSummarySchema = z.object({
+    total: z.number().int().min(0),
+    verified: z.number().int().min(0),
+    ok: z.number().int().min(0),
+    ko: z.number().int().min(0),
+    blocked: z.number().int().min(0),
+    untested: z.number().int().min(0),
+});
+/** Tâche d'un arbre (Kanban, liste, sous-tâches), avec ses sous-tâches. */
+export const TaskNodeSchema = z.object({
+    id: IdSchema,
+    /** Identifiant lisible : `ORG-41`. */
+    key: z.string(),
+    parentId: IdSchema.nullable(),
+    depth: z.number().int(),
+    type: TaskTypeSchema,
+    title: z.string(),
+    status: TaskStatusSchema,
+    priority: TaskPrioritySchema,
+    position: PositionSchema,
+    assigneeIds: z.array(IdSchema),
+    tagIds: z.array(IdSchema),
+    subtasks: ProgressSchema,
+    /** Bilan des points de vérification d'une tâche de test ; null pour une tâche standard. */
+    test: TestSummarySchema.nullable(),
+    get children() {
+        return z.array(TaskNodeSchema);
+    },
+});
+/** Filtres de l'arbre d'un espace ; une tâche est gardée si elle ou l'une de ses sous-tâches y répond. */
+export const TaskFiltersSchema = z.object({
+    type: TaskTypeSchema.optional(),
+    priority: TaskPrioritySchema.optional(),
+    assignee: IdSchema.optional(),
+    tag: IdSchema.optional(),
+});
+export const BoardResponseSchema = z.object({
+    spaceId: IdSchema,
+    members: z.array(MemberRefSchema),
+    tags: z.array(TagViewSchema),
+    /** Tâches de premier niveau, chacune avec ses sous-tâches. */
+    tasks: z.array(TaskNodeSchema),
+});
+export const TaskViewSchema = z.object({
+    id: IdSchema,
+    key: z.string(),
+    spaceId: IdSchema,
+    parentId: IdSchema.nullable(),
+    depth: z.number().int(),
+    type: TaskTypeSchema,
+    title: z.string(),
+    description: z.string(),
+    status: TaskStatusSchema,
+    priority: TaskPrioritySchema,
+    assigneeIds: z.array(IdSchema),
+    tagIds: z.array(IdSchema),
+    /** Tâche vérifiée par une tâche de test ; null sinon. */
+    testedTaskId: IdSchema.nullable(),
+    createdBy: IdSchema,
+    createdAt: TimestampSchema,
+    updatedAt: TimestampSchema,
+    version: z.number().int(),
+});
+export const TaskRefSchema = z.object({ id: IdSchema, key: z.string(), title: z.string() });
+export const ChecklistItemViewSchema = z.object({ id: IdSchema, text: z.string(), done: z.boolean(), position: PositionSchema });
+export const CommentViewSchema = z.object({
+    id: IdSchema,
+    authorId: IdSchema,
+    authorName: z.string(),
+    body: z.string(),
+    createdAt: TimestampSchema,
+    editedAt: TimestampSchema.nullable(),
+    /** Vrai pour un commentaire écrit par l'agent au nom de l'auteur d'une demande. */
+    byAgent: z.boolean(),
+});
+export const AttachmentViewSchema = z.object({
+    id: IdSchema,
+    filename: z.string(),
+    mime: z.string(),
+    size: z.number().int(),
+    uploaderId: IdSchema,
+    createdAt: TimestampSchema,
+});
+export const CheckpointViewSchema = z.object({ id: IdSchema, text: z.string(), position: PositionSchema });
+export const TestResultViewSchema = z.object({
+    checkpointId: IdSchema,
+    result: TestResultValueSchema,
+    comment: z.string(),
+    updatedAt: TimestampSchema,
+});
+/** Review soumise, avec l'état de la demande `test_review` qu'elle a créée (null si la demande n'existe plus). */
+export const SubmittedReviewViewSchema = z.object({
+    id: IdSchema,
+    testerId: IdSchema,
+    /** Nom affiché du testeur, membre ou ancien membre de l'espace. */
+    testerName: z.string(),
+    text: z.string(),
+    submittedAt: TimestampSchema,
+    requestId: IdSchema.nullable(),
+    requestStatus: RequestStatusSchema.nullable(),
+});
+/** Testeur d'une tâche de test : ses résultats saisis et son brouillon de review. */
+export const TesterViewSchema = z.object({
+    userId: IdSchema,
+    results: z.array(TestResultViewSchema),
+    /** Texte du brouillon de review en cours ; vide sans brouillon. */
+    draft: z.string(),
+});
+/** Ancien testeur (désassigné, ou qui a quitté l'espace) : ses résultats, en lecture seule. */
+export const PastTesterViewSchema = z.object({
+    userId: IdSchema,
+    name: z.string(),
+    results: z.array(TestResultViewSchema),
+});
+/** Partie propre à une tâche de test du détail. */
+export const TestDetailSchema = z.object({
+    checkpoints: z.array(CheckpointViewSchema),
+    summary: TestSummarySchema,
+    /** Assignés de la tâche, dans l'ordre des assignés. */
+    testers: z.array(TesterViewSchema),
+    /** Testeurs qui ont saisi des résultats sans être assignés aujourd'hui, par nom. */
+    pastTesters: z.array(PastTesterViewSchema),
+    /** Reviews soumises, de la plus récente à la plus ancienne. */
+    reviews: z.array(SubmittedReviewViewSchema),
+});
+export const TaskDetailResponseSchema = z.object({
+    task: TaskViewSchema,
+    /** Tâches parentes, de la racine au parent direct. */
+    ancestors: z.array(TaskRefSchema),
+    /** Tâche vérifiée par une tâche de test. */
+    testedTask: TaskRefSchema.nullable(),
+    children: z.array(TaskNodeSchema),
+    checklist: z.array(ChecklistItemViewSchema),
+    /** Points de vérification, résultats et reviews d'une tâche de test ; null pour une tâche standard. */
+    test: TestDetailSchema.nullable(),
+    comments: z.array(CommentViewSchema),
+    attachments: z.array(AttachmentViewSchema),
+    members: z.array(MemberRefSchema),
+    /** Tags de l'espace. */
+    tags: z.array(TagViewSchema),
+    /** Dernière modification de la tâche quand elle vient de l'agent : l'action à annuler et sa date. */
+    agentEdit: z.object({ actionId: IdSchema, at: TimestampSchema }).nullable(),
+});
+// --- Requêtes ---
+export const CreateTaskRequestSchema = z.object({
+    title: TaskTitleSchema,
+    parentId: IdSchema.nullable().optional(),
+    status: TaskStatusSchema.optional(),
+    type: TaskTypeSchema.optional(),
+    priority: TaskPrioritySchema.optional(),
+    description: z.string().optional(),
+});
+export const UpdateTaskRequestSchema = z
+    .object({
+    title: TaskTitleSchema.optional(),
+    description: z.string().optional(),
+    status: TaskStatusSchema.optional(),
+    priority: TaskPrioritySchema.optional(),
+    type: TaskTypeSchema.optional(),
+    parentId: IdSchema.nullable().optional(),
+    /** Tâche vérifiée, pour une tâche de test ; null retire le lien. */
+    testedTaskId: IdSchema.nullable().optional(),
+})
+    .refine((patch) => Object.values(patch).some((value) => value !== undefined), "Aucune modification demandée.");
+/** Déplacement Kanban : colonne cible, et tâche après laquelle se placer (null : en tête de colonne). */
+export const MoveTaskRequestSchema = z.object({ status: TaskStatusSchema, afterId: IdSchema.nullable() });
+export const SetAssigneesRequestSchema = z.object({ userIds: z.array(IdSchema) });
+export const SetTagsRequestSchema = z.object({ names: z.array(TagNameSchema) });
+export const ChecklistTextSchema = z.string().trim().min(1, "L'élément de checklist est vide.").max(500);
+export const AddChecklistItemRequestSchema = z.object({ text: ChecklistTextSchema });
+export const UpdateChecklistItemRequestSchema = z
+    .object({ text: ChecklistTextSchema.optional(), done: z.boolean().optional() })
+    .refine((patch) => patch.text !== undefined || patch.done !== undefined, "Aucune modification demandée.");
+/** Réordonnancement : élément après lequel se placer (null : en tête). */
+export const MoveAfterRequestSchema = z.object({ afterId: IdSchema.nullable() });
+export const CheckpointTextSchema = z.string().trim().min(1, "Le point de vérification est vide.").max(500);
+export const CheckpointTextRequestSchema = z.object({ text: CheckpointTextSchema });
+export const MAX_TEST_COMMENT_LENGTH = 2000;
+/** Résultat de l'utilisateur sur un point : valeur, commentaire, ou les deux. */
+export const SetTestResultRequestSchema = z
+    .object({
+    result: TestResultValueSchema.optional(),
+    comment: z.string().trim().max(MAX_TEST_COMMENT_LENGTH, `Le commentaire dépasse ${MAX_TEST_COMMENT_LENGTH} caractères.`).optional(),
+})
+    .refine((patch) => patch.result !== undefined || patch.comment !== undefined, "Aucune modification demandée.");
+export const MAX_REVIEW_LENGTH = 10_000;
+export const ReviewDraftRequestSchema = z.object({ text: z.string().max(MAX_REVIEW_LENGTH, `La review dépasse ${MAX_REVIEW_LENGTH} caractères.`) });
+export const ReviewDraftResponseSchema = z.object({ draft: z.string() });
+export const SubmitReviewRequestSchema = z.object({
+    text: z.string().trim().min(1, "La review est vide : décrivez ce que vous avez constaté.").max(MAX_REVIEW_LENGTH, `La review dépasse ${MAX_REVIEW_LENGTH} caractères.`),
+});
+export const CommentRequestSchema = z.object({ body: z.string().trim().min(1, "Le commentaire est vide.").max(10_000) });
+/** Type MIME `type/sous-type`, sans paramètres. */
+export const MimeTypeSchema = z.string().regex(/^[\w.+-]+\/[\w.+-]+$/, "Type de fichier invalide.");
+/** Pièce jointe transmise par le serveur web, qui lit le formulaire multipart du navigateur. */
+export const UploadAttachmentRequestSchema = z.object({
+    filename: z.string().trim().min(1, "Le fichier n'a pas de nom.").max(255),
+    mime: MimeTypeSchema,
+    contentBase64: z.string(),
+});
+/** Changements des espaces de l'utilisateur et numéro du dernier changement transmis. */
+export const ChangesResponseSchema = z.object({
+    seq: z.number().int().min(0),
+    changes: z.array(ChangeSchema),
+});

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

@@ -0,0 +1,106 @@
+import { z } from "zod";
+/** Corps des requêtes et des réponses des jetons d'agent dans la GUI (`/api/tokens`). */
+/** Longueur maximale du nom d'un jeton. */
+export declare const MAX_TOKEN_NAME_LENGTH = 80;
+/** Durée de validité maximale d'un jeton, en jours. */
+export declare const MAX_TOKEN_DAYS = 3650;
+/** Préfixe de tout jeton d'agent. */
+export declare const AGENT_TOKEN_PREFIX = "org_";
+/**
+ * État d'un jeton : actif ; révoqué ; expiré ; inactif quand son propriétaire
+ * n'est plus membre de l'espace couvert ou que son compte n'est plus actif.
+ */
+export declare const TOKEN_STATES: readonly ["active", "inactive", "expired", "revoked"];
+export declare const TokenStateSchema: z.ZodEnum<{
+    active: "active";
+    expired: "expired";
+    inactive: "inactive";
+    revoked: "revoked";
+}>;
+export type TokenState = z.infer<typeof TokenStateSchema>;
+export declare const CreateTokenRequestSchema: z.ZodObject<{
+    name: z.ZodString;
+    spaceId: z.ZodString;
+    expiresInDays: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export type CreateTokenRequest = z.infer<typeof CreateTokenRequestSchema>;
+/** Jeton tel que le liste la GUI : jamais sa valeur ni son hash. */
+export declare const AgentTokenViewSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    prefix: z.ZodString;
+    space: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        kind: z.ZodEnum<{
+            personal: "personal";
+            shared: "shared";
+        }>;
+    }, z.core.$strip>;
+    state: z.ZodEnum<{
+        active: "active";
+        expired: "expired";
+        inactive: "inactive";
+        revoked: "revoked";
+    }>;
+    createdAt: z.ZodISODateTime;
+    lastUsedAt: z.ZodNullable<z.ZodISODateTime>;
+    expiresAt: z.ZodNullable<z.ZodISODateTime>;
+    revokedAt: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strip>;
+export type AgentTokenView = z.infer<typeof AgentTokenViewSchema>;
+export declare const TokenListResponseSchema: z.ZodObject<{
+    tokens: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        prefix: z.ZodString;
+        space: z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            kind: z.ZodEnum<{
+                personal: "personal";
+                shared: "shared";
+            }>;
+        }, z.core.$strip>;
+        state: z.ZodEnum<{
+            active: "active";
+            expired: "expired";
+            inactive: "inactive";
+            revoked: "revoked";
+        }>;
+        createdAt: z.ZodISODateTime;
+        lastUsedAt: z.ZodNullable<z.ZodISODateTime>;
+        expiresAt: z.ZodNullable<z.ZodISODateTime>;
+        revokedAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type TokenListResponse = z.infer<typeof TokenListResponseSchema>;
+/** Jeton créé : sa valeur, montrée une seule fois, et l'entrée `.mcp.json` du mode MCP qui l'utilise. */
+export declare const CreatedTokenResponseSchema: z.ZodObject<{
+    token: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        prefix: z.ZodString;
+        space: z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            kind: z.ZodEnum<{
+                personal: "personal";
+                shared: "shared";
+            }>;
+        }, z.core.$strip>;
+        state: z.ZodEnum<{
+            active: "active";
+            expired: "expired";
+            inactive: "inactive";
+            revoked: "revoked";
+        }>;
+        createdAt: z.ZodISODateTime;
+        lastUsedAt: z.ZodNullable<z.ZodISODateTime>;
+        expiresAt: z.ZodNullable<z.ZodISODateTime>;
+        revokedAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strip>;
+    value: z.ZodString;
+    mcpJson: z.ZodString;
+}, z.core.$strip>;
+export type CreatedTokenResponse = z.infer<typeof CreatedTokenResponseSchema>;

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

@@ -0,0 +1,42 @@
+import { z } from "zod";
+import { SpaceKindSchema } from "./enums.schema.js";
+import { IdSchema, TimestampSchema } from "./entities.schema.js";
+/** Corps des requêtes et des réponses des jetons d'agent dans la GUI (`/api/tokens`). */
+/** Longueur maximale du nom d'un jeton. */
+export const MAX_TOKEN_NAME_LENGTH = 80;
+/** Durée de validité maximale d'un jeton, en jours. */
+export const MAX_TOKEN_DAYS = 3650;
+/** Préfixe de tout jeton d'agent. */
+export const AGENT_TOKEN_PREFIX = "org_";
+/**
+ * État d'un jeton : actif ; révoqué ; expiré ; inactif quand son propriétaire
+ * n'est plus membre de l'espace couvert ou que son compte n'est plus actif.
+ */
+export const TOKEN_STATES = ["active", "inactive", "expired", "revoked"];
+export const TokenStateSchema = z.enum(TOKEN_STATES);
+export const CreateTokenRequestSchema = z.object({
+    name: z.string().trim().min(1, "Le nom du jeton est requis.").max(MAX_TOKEN_NAME_LENGTH, `Le nom du jeton dépasse ${MAX_TOKEN_NAME_LENGTH} caractères.`),
+    spaceId: IdSchema,
+    /** Durée de validité en jours ; null : sans expiration. */
+    expiresInDays: z.number().int().min(1, "Durée de validité invalide.").max(MAX_TOKEN_DAYS, "Durée de validité invalide.").nullable(),
+});
+/** Jeton tel que le liste la GUI : jamais sa valeur ni son hash. */
+export const AgentTokenViewSchema = z.object({
+    id: IdSchema,
+    name: z.string(),
+    /** Début du jeton (`org_AbCd1234`), pour le reconnaître. */
+    prefix: z.string(),
+    space: z.object({ id: IdSchema, name: z.string(), kind: SpaceKindSchema }),
+    state: TokenStateSchema,
+    createdAt: TimestampSchema,
+    lastUsedAt: TimestampSchema.nullable(),
+    expiresAt: TimestampSchema.nullable(),
+    revokedAt: TimestampSchema.nullable(),
+});
+export const TokenListResponseSchema = z.object({ tokens: z.array(AgentTokenViewSchema) });
+/** Jeton créé : sa valeur, montrée une seule fois, et l'entrée `.mcp.json` du mode MCP qui l'utilise. */
+export const CreatedTokenResponseSchema = z.object({
+    token: AgentTokenViewSchema,
+    value: z.string().startsWith(AGENT_TOKEN_PREFIX),
+    mcpJson: z.string(),
+});

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

@@ -0,0 +1,15 @@
+import { z } from "zod";
+/** Corps des requêtes et des réponses de la dictée vocale. */
+/** Taille maximale d'un enregistrement transcrit : 25 Mo, limite de l'API Groq. */
+export declare const MAX_TRANSCRIPTION_BYTES: number;
+/** Enregistrement transmis par le serveur web, qui lit le formulaire multipart du navigateur (champ `file`). */
+export declare const TranscribeRequestSchema: z.ZodObject<{
+    filename: z.ZodString;
+    mime: z.ZodString;
+    contentBase64: z.ZodString;
+}, z.core.$strip>;
+export type TranscribeRequest = z.infer<typeof TranscribeRequestSchema>;
+export declare const TranscribeResponseSchema: z.ZodObject<{
+    text: z.ZodString;
+}, z.core.$strip>;
+export type TranscribeResponse = z.infer<typeof TranscribeResponseSchema>;

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

@@ -0,0 +1,12 @@
+import { z } from "zod";
+import { MimeTypeSchema } from "./tasks-api.schema.js";
+/** Corps des requêtes et des réponses de la dictée vocale. */
+/** Taille maximale d'un enregistrement transcrit : 25 Mo, limite de l'API Groq. */
+export const MAX_TRANSCRIPTION_BYTES = 25 * 1024 * 1024;
+/** Enregistrement transmis par le serveur web, qui lit le formulaire multipart du navigateur (champ `file`). */
+export const TranscribeRequestSchema = z.object({
+    filename: z.string().trim().min(1, "L'enregistrement n'a pas de nom.").max(255),
+    mime: MimeTypeSchema,
+    contentBase64: z.string(),
+});
+export const TranscribeResponseSchema = z.object({ text: z.string() });

package/dist/src/agent-api/checklist.d.ts

@@ -0,0 +1,3 @@
+import { type AgentRoute } from "./types.js";
+/** Checklist d'une tâche standard, ou points de vérification d'une tâche de test : opérations appliquées en ordre, tout ou rien. */
+export declare const checklistRoutes: AgentRoute[];

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

@@ -0,0 +1,127 @@
+import { ChecklistDataSchema, EditChecklistBodySchema } from "../../shared/schemas/agent-tools.schema.js";
+import { actFor, quote, resolveTask, taskData, taskKey } from "../core/agent.js";
+import { InvariantError, NotFoundError, OrganizerError } from "../core/errors.js";
+import { snapshotOf } from "../core/snapshots.js";
+import { parseInput, respond } from "./types.js";
+/** Checklist d'une tâche standard, ou points de vérification d'une tâche de test : opérations appliquées en ordre, tout ou rien. */
+export const checklistRoutes = [
+    {
+        method: "POST",
+        path: "/tasks/:ref/checklist",
+        handle: ({ store }, { agent, params, body }) => {
+            const input = parseInput(EditChecklistBodySchema, body);
+            const { task, outcomes } = actFor(store, agent, input.request_id, (tx, space) => {
+                const task = resolveTask(tx.store, space, params.ref);
+                return { task, outcomes: input.operations.map((operation) => apply(tx, task, operation)) };
+            });
+            const items = task.type === "standard"
+                ? store.listChecklist(task.id).map((item) => ({ id: item.id, text: item.text, done: item.done }))
+                : store.listCheckpoints(task.id).map((checkpoint) => ({ id: checkpoint.id, text: checkpoint.text, done: null }));
+            const current = items.map((item) => (item.done === null ? `- ${item.text} (id ${item.id})` : `- [${item.done ? "x" : " "}] ${item.text} (id ${item.id})`));
+            return respond(ChecklistDataSchema, `${taskKey(store, task)}: ${outcomes.join("; ")}.\n${task.type === "standard" ? "Checklist" : "Checkpoints"} now:\n${current.join("\n") || "(empty)"}`, { task: taskData(store, task), items });
+        },
+    },
+];
+/** Applique une opération et l'enregistre dans le lot ; renvoie sa description pour la réponse. */
+function apply(tx, task, operation) {
+    return task.type === "standard" ? applyToChecklist(tx, task, operation) : applyToCheckpoints(tx, task, operation);
+}
+function applyToChecklist(tx, task, operation) {
+    const store = tx.store;
+    if (operation.action === "add") {
+        const item = tx.addChecklistItem(task.id, operation.text);
+        tx.recordAgentAction({
+            entityType: "checklist_item",
+            entityId: item.id,
+            operation: "create",
+            before: null,
+            after: item,
+            summary: `Élément ajouté : ${quote(item.text)}`,
+            taskId: task.id,
+        });
+        return `added item ${item.id}`;
+    }
+    const current = store.findChecklistItem(operation.item_id);
+    if (!current || current.taskId !== task.id)
+        throw new NotFoundError(`Checklist item ${operation.item_id} is not in this task. Call get_task to get the item ids.`);
+    if (operation.action === "delete") {
+        tx.deleteChecklistItem(current.id);
+        tx.recordAgentAction({
+            entityType: "checklist_item",
+            entityId: current.id,
+            operation: "delete",
+            before: current,
+            after: null,
+            summary: `Élément supprimé : ${quote(current.text)}`,
+            taskId: task.id,
+        });
+        return `deleted item ${current.id}`;
+    }
+    if (operation.text === undefined && operation.done === undefined)
+        throw new OrganizerError(`Nothing to update on item ${current.id}: give text or done.`);
+    const item = tx.updateChecklistItem(current.id, { text: operation.text, done: operation.done });
+    const parts = [];
+    if (item.text !== current.text)
+        parts.push(`Élément ${quote(current.text)} renommé en ${quote(item.text)}`);
+    if (item.done !== current.done)
+        parts.push(`Élément ${quote(item.text)} ${item.done ? "coché" : "décoché"}`);
+    tx.recordAgentAction({
+        entityType: "checklist_item",
+        entityId: item.id,
+        operation: "update",
+        before: current,
+        after: item,
+        summary: parts.join(" · ") || `Élément ${quote(item.text)} inchangé`,
+        taskId: task.id,
+    });
+    return `updated item ${item.id}`;
+}
+function applyToCheckpoints(tx, task, operation) {
+    const store = tx.store;
+    if (operation.action === "add") {
+        const checkpoint = tx.addCheckpoint(task.id, operation.text);
+        tx.recordAgentAction({
+            entityType: "test_checkpoint",
+            entityId: checkpoint.id,
+            operation: "create",
+            before: null,
+            after: snapshotOf(store, "test_checkpoint", checkpoint.id),
+            summary: `Point de vérification ajouté : ${quote(checkpoint.text)}`,
+            taskId: task.id,
+        });
+        return `added checkpoint ${checkpoint.id}`;
+    }
+    const current = store.findCheckpoint(operation.item_id);
+    if (!current || current.taskId !== task.id)
+        throw new NotFoundError(`Checkpoint ${operation.item_id} is not in this test task. Call get_task to get the checkpoint ids.`);
+    const before = snapshotOf(store, "test_checkpoint", current.id);
+    if (operation.action === "delete") {
+        tx.deleteCheckpoint(current.id);
+        tx.recordAgentAction({
+            entityType: "test_checkpoint",
+            entityId: current.id,
+            operation: "delete",
+            before,
+            after: null,
+            summary: `Point de vérification supprimé : ${quote(current.text)}`,
+            taskId: task.id,
+        });
+        return `deleted checkpoint ${current.id}`;
+    }
+    if (operation.done !== undefined) {
+        throw new InvariantError("A test checkpoint cannot be checked: testers record their own results. Only update its text.");
+    }
+    if (operation.text === undefined)
+        throw new OrganizerError(`Nothing to update on checkpoint ${current.id}: give its new text.`);
+    const checkpoint = tx.updateCheckpoint(current.id, operation.text);
+    tx.recordAgentAction({
+        entityType: "test_checkpoint",
+        entityId: checkpoint.id,
+        operation: "update",
+        before,
+        after: snapshotOf(store, "test_checkpoint", checkpoint.id),
+        summary: `Point ${quote(current.text)} renommé en ${quote(checkpoint.text)}`,
+        taskId: task.id,
+    });
+    return `updated checkpoint ${checkpoint.id}`;
+}

package/dist/src/agent-api/ideas.d.ts

@@ -0,0 +1,3 @@
+import { type AgentRoute } from "./types.js";
+/** Boîte à idées de l'espace du jeton : ajout, reformulation, archivage, promotion en tâche. */
+export declare const ideaRoutes: AgentRoute[];

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

@@ -0,0 +1,93 @@
+import { CreateIdeaBodySchema, IdeaDataSchema, PromoteIdeaBodySchema, PromoteIdeaDataSchema, UpdateIdeaBodySchema } from "../../shared/schemas/agent-tools.schema.js";
+import { actFor, ideaData, quote, requireText, resolveIdea, resolveTask, taskData, taskKey } from "../core/agent.js";
+import { InvariantError, OrganizerError } from "../core/errors.js";
+import { parseInput, respond } from "./types.js";
+/** Boîte à idées de l'espace du jeton : ajout, reformulation, archivage, promotion en tâche. */
+export const ideaRoutes = [
+    {
+        method: "POST",
+        path: "/ideas",
+        handle: ({ store }, { agent, body }) => {
+            const input = parseInput(CreateIdeaBodySchema, body);
+            const text = requireText(input.text, "text");
+            const { space, idea } = actFor(store, agent, input.request_id, (tx, space) => {
+                const idea = tx.createIdea({ spaceId: space.id, text });
+                tx.recordAgentAction({ entityType: "idea", entityId: idea.id, operation: "create", before: null, after: idea, summary: `Idée ajoutée : ${quote(idea.text)}`, taskId: null });
+                return { space, idea };
+            });
+            return respond(IdeaDataSchema, `Added idea ${idea.id} to the idea box of "${space.name}".`, { idea: ideaData(store, idea) });
+        },
+    },
+    {
+        method: "PATCH",
+        path: "/ideas/:ideaId",
+        handle: ({ store }, { agent, params, body }) => {
+            const input = parseInput(UpdateIdeaBodySchema, body);
+            if (input.text === undefined && input.archived === undefined)
+                throw new OrganizerError("Nothing to change: give text or archived.");
+            const text = input.text === undefined ? undefined : requireText(input.text, "text");
+            const updated = actFor(store, agent, input.request_id, (tx, space) => {
+                const idea = resolveIdea(tx.store, space, params.ideaId);
+                const updated = tx.updateIdea(idea.id, { text, archived: input.archived });
+                const parts = [];
+                if (updated.text !== idea.text)
+                    parts.push(`Idée reformulée : ${quote(updated.text)}`);
+                if ((updated.archivedAt !== null) !== (idea.archivedAt !== null)) {
+                    parts.push(updated.archivedAt !== null ? `Idée archivée : ${quote(updated.text)}` : `Idée désarchivée : ${quote(updated.text)}`);
+                }
+                tx.recordAgentAction({
+                    entityType: "idea",
+                    entityId: idea.id,
+                    operation: "update",
+                    before: idea,
+                    after: updated,
+                    summary: parts.join(" · ") || `Idée inchangée : ${quote(updated.text)}`,
+                    taskId: null,
+                });
+                return updated;
+            });
+            return respond(IdeaDataSchema, `Idea ${updated.id} updated${updated.archivedAt !== null ? " (archived)" : ""}.`, { idea: ideaData(store, updated) });
+        },
+    },
+    {
+        method: "POST",
+        path: "/ideas/:ideaId/promote",
+        handle: ({ store }, { agent, params, body }) => {
+            const input = parseInput(PromoteIdeaBodySchema, body);
+            const title = requireText(input.title, "title");
+            const { idea, task } = actFor(store, agent, input.request_id, (tx, space) => {
+                const idea = resolveIdea(tx.store, space, params.ideaId);
+                if (idea.promotedTaskId !== null && tx.store.findTask(idea.promotedTaskId)) {
+                    const existing = tx.store.getTask(idea.promotedTaskId);
+                    throw new InvariantError(`Idea ${idea.id} is already promoted to ${taskKey(tx.store, existing)}. Update that task with update_task instead.`);
+                }
+                const parent = input.parent === undefined ? null : resolveTask(tx.store, space, input.parent);
+                const task = tx.createTask({ spaceId: space.id, parentId: parent?.id ?? null, title, description: input.description, type: input.type, priority: input.priority });
+                tx.recordAgentAction({
+                    entityType: "task",
+                    entityId: task.id,
+                    operation: "create",
+                    before: null,
+                    after: tx.store.taskSnapshot(task.id),
+                    summary: `Tâche créée depuis l'idée : ${quote(task.title)}`,
+                    taskId: task.id,
+                });
+                const promoted = tx.updateIdea(idea.id, { promotedTaskId: task.id });
+                tx.recordAgentAction({
+                    entityType: "idea",
+                    entityId: idea.id,
+                    operation: "update",
+                    before: idea,
+                    after: promoted,
+                    summary: `Idée promue en ${taskKey(tx.store, task)}`,
+                    taskId: null,
+                });
+                return { idea: promoted, task };
+            });
+            return respond(PromoteIdeaDataSchema, `Idea ${idea.id} promoted to ${taskKey(store, task)} "${task.title}" (id ${task.id}).`, {
+                idea: ideaData(store, idea),
+                task: taskData(store, task),
+            });
+        },
+    },
+];

package/dist/src/agent-api/requests.d.ts

@@ -0,0 +1,3 @@
+import { type AgentRoute } from "./types.js";
+/** Demandes de l'espace du jeton : liste, prise, fin (réussie ou en échec). */
+export declare const requestRoutes: AgentRoute[];