@imenam/mcp-organizer 0.0.0-stage → 1.0.2

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

@@ -0,0 +1,91 @@
+import { MAX_REQUEST_LIST_LIMIT, NoQuerySchema, NotificationsDataSchema, WaitRequestsDataSchema, WaitRequestsQuerySchema, } from "../../shared/schemas/agent-tools.schema.js";
+import { resolveAgentToken } from "../core/agent-tokens.js";
+import { requestData, requestLine, spaceData } from "../core/agent.js";
+import { parseInput, respond } from "./types.js";
+/**
+ * Notifications de l'agent : état (`GET notifications`) et attente longue
+ * des demandes qui passent en attente (`GET requests/wait`), appelée en
+ * boucle par le veilleur que lance `enable_notifications`.
+ */
+export const notificationRoutes = [
+    {
+        method: "GET",
+        path: "/notifications",
+        handle: ({ store }, { agent, query }) => {
+            parseInput(NoQuerySchema, query);
+            const watcher = store.watchers.status(agent.token.id);
+            const pendingCount = store.countPendingRequestsOfSpace(agent.space.id);
+            const state = watcher.armed ? `a watcher is armed for this token since ${watcher.since}` : "no watcher is armed for this token";
+            return respond(NotificationsDataSchema, `Space "${agent.space.name}": ${pendingCount} pending request(s); ${state}.`, {
+                token: { id: agent.token.id, name: agent.token.name },
+                space: spaceData(agent.space),
+                pendingCount,
+                watcher,
+            });
+        },
+    },
+];
+/** Demandes en attente de l'espace du jeton modifiées strictement après `since`. */
+function pendingSince(ctx, agent, since) {
+    return ctx.store.listAgentRequestsTargeting(agent.space.id, "pending", MAX_REQUEST_LIST_LIMIT).filter((request) => request.updatedAt > since);
+}
+function waitResponse(ctx, agent, requests, cursor, timeoutSeconds) {
+    const data = {
+        space: spaceData(agent.space),
+        requests: requests.map((request) => requestData(ctx.store, agent, request)),
+        cursor,
+        timedOut: requests.length === 0,
+    };
+    if (requests.length === 0)
+        return respond(WaitRequestsDataSchema, `No new pending request in "${agent.space.name}" after ${timeoutSeconds}s.`, data);
+    const lines = requests.map((request) => requestLine(ctx.store, agent, request)).join("\n");
+    return respond(WaitRequestsDataSchema, `${requests.length} new pending request(s) in "${agent.space.name}":\n${lines}\n\nNext: call claim_request with the id of the oldest request.`, data);
+}
+/**
+ * `GET requests/wait` : rend aussitôt les demandes passées en attente depuis
+ * `since`, sinon attend qu'une demande de l'espace du jeton passe en attente
+ * (création ou libération), au plus `timeout_seconds`. Le curseur rendu est
+ * l'horodatage de la dernière demande rendue, ou le point de départ de
+ * l'attente à l'expiration. Une attente `watcher=true` compte dans la
+ * présence du veilleur du jeton.
+ */
+export function waitForPendingRequests(ctx, request, signal) {
+    const agent = resolveAgentToken(ctx.store, request.bearer, ctx.now?.() ?? new Date());
+    const input = parseInput(WaitRequestsQuerySchema, request.query);
+    const startedAt = new Date().toISOString();
+    const since = input.since ?? null;
+    if (since !== null) {
+        const ready = pendingSince(ctx, agent, since);
+        if (ready.length > 0)
+            return Promise.resolve(waitResponse(ctx, agent, ready, ready.map((r) => r.updatedAt).sort().at(-1), input.timeout_seconds));
+    }
+    return new Promise((resolve) => {
+        const releaseWatcher = input.watcher ? ctx.store.watchers.begin(agent.token.id) : () => { };
+        const received = [];
+        let flush = null;
+        const stop = () => {
+            clearTimeout(timer);
+            if (flush)
+                clearImmediate(flush);
+            unsubscribe();
+            signal.removeEventListener("abort", onAbort);
+            releaseWatcher();
+        };
+        const finish = (requests, cursor) => {
+            stop();
+            resolve(waitResponse(ctx, agent, requests, cursor, input.timeout_seconds));
+        };
+        // Les demandes d'une même mutation arrivent ensemble : elles partent dans la même réponse.
+        const unsubscribe = ctx.store.onPendingRequest((pending) => {
+            if (pending.targetSpaceId !== agent.space.id || pending.status !== "pending")
+                return;
+            received.push(pending);
+            flush ??= setImmediate(() => finish(received, received.map((r) => r.updatedAt).sort().at(-1)));
+        });
+        const timer = setTimeout(() => finish([], since ?? startedAt), input.timeout_seconds * 1000);
+        const onAbort = () => stop();
+        signal.addEventListener("abort", onAbort);
+        if (signal.aborted)
+            stop();
+    });
+}

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[];

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

@@ -0,0 +1,60 @@
+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 { parseInput, respond } from "./types.js";
+/** Demandes de l'espace du jeton : liste, prise, fin (réussie ou en échec). */
+export const requestRoutes = [
+    {
+        method: "GET",
+        path: "/requests",
+        handle: ({ store }, { agent, query }) => {
+            const input = parseInput(ListRequestsQuerySchema, query);
+            const requests = store.listAgentRequestsTargeting(agent.space.id, input.status === "all" ? null : input.status, input.limit);
+            const data = { space: spaceData(agent.space), requests: requests.map((request) => requestData(store, agent, request)) };
+            if (requests.length === 0) {
+                const none = input.status === "pending" ? `No pending request in "${agent.space.name}".` : `No ${input.status === "all" ? "" : `${input.status} `}request in "${agent.space.name}".`;
+                return respond(ListRequestsDataSchema, none, data);
+            }
+            const next = input.status === "pending" ? "\n\nNext: call claim_request with the id of the oldest request." : "";
+            const lines = requests.map((request) => requestLine(store, agent, request)).join("\n");
+            return respond(ListRequestsDataSchema, `${requests.length} request(s) in "${agent.space.name}":\n${lines}${next}`, data);
+        },
+    },
+    {
+        method: "POST",
+        path: "/requests/:requestId/claim",
+        handle: ({ store }, { agent, params, body }) => {
+            parseInput(ClaimRequestBodySchema, body);
+            requestOfSpace(store, agent, params.requestId);
+            const request = store.mutate(agentActor(agent, params.requestId), (tx) => tx.claimAgentRequest());
+            return respond(ClaimRequestDataSchema, requestContext(store, agent, request), {
+                request: requestData(store, agent, request),
+                space: spaceData(agent.space),
+                members: memberData(store, agent.space),
+                tasks: treeData(store, agent.space),
+                ideas: recentIdeas(store, agent.space).map((idea) => ideaData(store, idea)),
+            });
+        },
+    },
+    {
+        method: "POST",
+        path: "/requests/:requestId/complete",
+        handle: ({ store }, { agent, params, body }) => {
+            const input = parseInput(CompleteRequestBodySchema, body);
+            requestOfSpace(store, agent, params.requestId);
+            const done = store.mutate(agentActor(agent, params.requestId), (tx) => tx.completeAgentRequest(input.reply));
+            const actionCount = store.listAgentActions(done.id).length;
+            return respond(FinishRequestDataSchema, `Request ${done.id} is done (${actionCount} action(s) in its batch). Call list_requests for the next one.`, { request: requestData(store, agent, done), actionCount });
+        },
+    },
+    {
+        method: "POST",
+        path: "/requests/:requestId/fail",
+        handle: ({ store }, { agent, params, body }) => {
+            const input = parseInput(FailRequestBodySchema, body);
+            requestOfSpace(store, agent, params.requestId);
+            const failed = store.mutate(agentActor(agent, params.requestId), (tx) => tx.failAgentRequest(input.reason));
+            const actionCount = store.listAgentActions(failed.id).length;
+            return respond(FinishRequestDataSchema, `Request ${failed.id} is marked as failed; its author sees your reason. Call list_requests for the next one.`, { request: requestData(store, agent, failed), actionCount });
+        },
+    },
+];

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

@@ -0,0 +1,3 @@
+import type { AgentApiContext, AgentApiRequest, AgentApiResponse } from "./types.js";
+/** Traite une requête de l'API agent ; une erreur est levée telle quelle, avec la nature qui fixe son code HTTP. */
+export declare function handleAgentRequest(ctx: AgentApiContext, request: AgentApiRequest): AgentApiResponse;

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

@@ -0,0 +1,41 @@
+import { resolveAgentToken } from "../core/agent-tokens.js";
+import { NotFoundError, OrganizerError } from "../core/errors.js";
+import { checklistRoutes } from "./checklist.js";
+import { ideaRoutes } from "./ideas.js";
+import { notificationRoutes } from "./notifications.js";
+import { requestRoutes } from "./requests.js";
+import { taskRoutes } from "./tasks.js";
+function compile(route) {
+    const keys = [];
+    const source = route.path.replace(/:([A-Za-z]+)/g, (_, key) => {
+        keys.push(key);
+        return "([^/]+)";
+    });
+    return { route, pattern: new RegExp(`^${source}$`), keys };
+}
+const ROUTES = [...requestRoutes, ...taskRoutes, ...checklistRoutes, ...ideaRoutes, ...notificationRoutes].map(compile);
+/** Segment de chemin décodé ; un encodage `%` invalide est une erreur 400. */
+function decodeSegment(raw) {
+    try {
+        return decodeURIComponent(raw);
+    }
+    catch {
+        throw new OrganizerError(`Invalid URL: a path segment is badly encoded (${raw}).`);
+    }
+}
+/** Traite une requête de l'API agent ; une erreur est levée telle quelle, avec la nature qui fixe son code HTTP. */
+export function handleAgentRequest(ctx, request) {
+    const now = ctx.now?.() ?? new Date();
+    const agent = resolveAgentToken(ctx.store, request.bearer, now);
+    for (const candidate of ROUTES) {
+        if (candidate.route.method !== request.method)
+            continue;
+        const match = candidate.pattern.exec(request.path);
+        if (!match)
+            continue;
+        const params = {};
+        candidate.keys.forEach((key, index) => (params[key] = decodeSegment(match[index + 1])));
+        return candidate.route.handle(ctx, { agent, params, query: request.query, body: request.body });
+    }
+    throw new NotFoundError(`Unknown agent API route: ${request.method} /api/agent${request.path}. Update @imenam/mcp-organizer so that the MCP mode and the site agree.`);
+}

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

@@ -0,0 +1,2 @@
+import { type AgentRoute } from "./types.js";
+export declare const taskRoutes: AgentRoute[];

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

@@ -0,0 +1,290 @@
+import { AddCommentBodySchema, CommentDataSchema, ContextDataSchema, CreateTaskBodySchema, NoQuerySchema, SearchTasksDataSchema, SearchTasksQuerySchema, SetAssigneesBodySchema, SetTagsBodySchema, TaskDataSchema, TaskDetailDataSchema, UpdateTaskBodySchema, } from "../../shared/schemas/agent-tools.schema.js";
+import { combinedResult } from "../../shared/logic/test-summary.js";
+import { actFor, ago, assigneesSummary, createdTaskSummary, ideaData, memberData, recentIdeas, requireText, resolveMembers, resolveTask, spaceContextLines, spaceData, taskData, taskKey, taskUpdateSummary, treeData, userLabel, } from "../core/agent.js";
+import { OrganizerError } from "../core/errors.js";
+import { parseInput, respond } from "./types.js";
+/** Espace du jeton et ses tâches : contexte, lecture, recherche, création, modification, assignés, tags, commentaires. */
+/** Nombre de commentaires récents affichés par get_task. */
+const RECENT_COMMENTS = 15;
+export const taskRoutes = [
+    {
+        method: "GET",
+        path: "/context",
+        handle: ({ store }, { agent, query }) => {
+            parseInput(NoQuerySchema, query);
+            const space = agent.space;
+            const header = `Your space: "${space.name}" (${space.kind}, task keys ${space.keyPrefix}-<number>). You act with the rights of ${userLabel(agent.user)} <${agent.user.email}>.`;
+            return respond(ContextDataSchema, [header, "", ...spaceContextLines(store, space)].join("\n"), {
+                space: spaceData(space),
+                members: memberData(store, space),
+                tasks: treeData(store, space),
+                ideas: recentIdeas(store, space).map((idea) => ideaData(store, idea)),
+            });
+        },
+    },
+    {
+        method: "GET",
+        path: "/tasks/:ref",
+        handle: ({ store }, { agent, params, query }) => {
+            parseInput(NoQuerySchema, query);
+            const task = resolveTask(store, agent.space, params.ref);
+            const name = (id) => {
+                const user = store.findUser(id);
+                return user ? userLabel(user) : id;
+            };
+            const lines = [];
+            lines.push(`${taskKey(store, task)} "${task.title}" (id ${task.id})`);
+            lines.push(`Type: ${task.type} · Status: ${task.status} · Priority: ${task.priority} · Depth: ${task.depth}`);
+            const ancestors = [];
+            for (let parentId = task.parentId; parentId !== null;) {
+                const parent = store.getTask(parentId);
+                ancestors.unshift(`${taskKey(store, parent)} "${parent.title}"`);
+                parentId = parent.parentId;
+            }
+            if (ancestors.length > 0)
+                lines.push(`Parents: ${ancestors.join(" > ")}`);
+            const tested = task.testedTaskId === null ? null : store.findTask(task.testedTaskId);
+            if (tested)
+                lines.push(`Tests: ${taskKey(store, tested)} "${tested.title}"`);
+            const tests = store.listTestsOf(task.id);
+            if (tests.length > 0)
+                lines.push(`Tested by: ${tests.map((test) => `${taskKey(store, test)} "${test.title}"`).join(", ")}`);
+            const assignees = store.listAssigneeIds(task.id);
+            lines.push(`${task.type === "test" ? "Testers" : "Assignees"}: ${assignees.length > 0 ? assignees.map(name).join(", ") : "none"}`);
+            const summary = taskData(store, task);
+            lines.push(`Tags: ${summary.tags.length > 0 ? summary.tags.join(", ") : "none"}`);
+            lines.push(`Created by ${name(task.createdBy)} ${ago(task.createdAt)}, updated ${ago(task.updatedAt)}.`);
+            lines.push("", "Description:", task.description.trim() === "" ? "(empty)" : task.description);
+            const checklist = task.type === "standard" ? store.listChecklist(task.id) : [];
+            const checkpoints = [];
+            if (task.type === "standard") {
+                lines.push("", `Checklist (${checklist.filter((item) => item.done).length}/${checklist.length} done):`);
+                lines.push(...(checklist.length > 0 ? checklist.map((item) => `- [${item.done ? "x" : " "}] ${item.text} (id ${item.id})`) : ["(empty)"]));
+            }
+            else {
+                const results = store.listTestResults(task.id).filter((result) => assignees.includes(result.testerId));
+                const points = store.listCheckpoints(task.id);
+                lines.push("", `Test checkpoints (${points.length}):`);
+                for (const checkpoint of points) {
+                    const own = results.filter((result) => result.checkpointId === checkpoint.id);
+                    const combined = combinedResult(own.map((result) => result.result));
+                    checkpoints.push({ id: checkpoint.id, text: checkpoint.text, result: combined });
+                    const comments = own.filter((result) => result.comment.trim() !== "").map((result) => `${name(result.testerId)}: ${result.comment}`);
+                    lines.push(`- [${combined}] ${checkpoint.text} (id ${checkpoint.id})${comments.length > 0 ? ` — ${comments.join(" | ")}` : ""}`);
+                }
+                if (points.length === 0)
+                    lines.push("(none)");
+                const reviews = store.listTestReviews(task.id).filter((review) => review.submittedAt !== null);
+                if (reviews.length > 0) {
+                    lines.push("", "Submitted reviews:");
+                    for (const review of reviews)
+                        lines.push(`- ${name(review.testerId)}, ${ago(review.submittedAt)}: ${review.text}`);
+                }
+            }
+            const children = store.listChildren(task.id);
+            if (children.length > 0) {
+                lines.push("", "Sub-tasks:");
+                for (const child of children)
+                    lines.push(`- ${taskKey(store, child)} [${child.status}, ${child.priority}${child.type === "test" ? ", test" : ""}] ${child.title}`);
+            }
+            const comments = store.listComments(task.id).slice(-RECENT_COMMENTS);
+            if (comments.length > 0) {
+                lines.push("", "Recent comments:");
+                for (const comment of comments)
+                    lines.push(`- ${comment.requestId ? "agent" : name(comment.authorId)}, ${ago(comment.createdAt)}: ${comment.body}`);
+            }
+            const attachments = store.listAttachments(task.id);
+            if (attachments.length > 0)
+                lines.push("", `Attachments: ${attachments.map((attachment) => attachment.filename).join(", ")}`);
+            return respond(TaskDetailDataSchema, lines.join("\n"), {
+                task: summary,
+                description: task.description,
+                testedTaskKey: tested ? taskKey(store, tested) : null,
+                checklist: checklist.map((item) => ({ id: item.id, text: item.text, done: item.done })),
+                checkpoints,
+                children: children.map((child) => taskData(store, child)),
+                comments: comments.map((comment) => ({
+                    id: comment.id,
+                    authorName: comment.requestId ? "agent" : name(comment.authorId),
+                    byAgent: comment.requestId !== null,
+                    body: comment.body,
+                    createdAt: comment.createdAt,
+                })),
+                attachments: attachments.map((attachment) => attachment.filename),
+            });
+        },
+    },
+    {
+        method: "GET",
+        path: "/tasks",
+        handle: ({ store }, { agent, query }) => {
+            const input = parseInput(SearchTasksQuerySchema, query);
+            const space = agent.space;
+            const assignee = input.assignee === undefined ? null : resolveMembers(store, space, [input.assignee])[0];
+            const words = (input.query ?? "").toLowerCase().split(/\s+/).filter((word) => word !== "");
+            const matches = store.listTasks(space.id).filter((task) => {
+                if (input.status && task.status !== input.status)
+                    return false;
+                if (input.priority && task.priority !== input.priority)
+                    return false;
+                if (input.type && task.type !== input.type)
+                    return false;
+                if (assignee && !store.listAssigneeIds(task.id).includes(assignee.id))
+                    return false;
+                const haystack = `${taskKey(store, task)} ${task.title} ${task.description}`.toLowerCase();
+                return words.every((word) => haystack.includes(word));
+            });
+            if (matches.length === 0)
+                return respond(SearchTasksDataSchema, `No task of "${space.name}" matches. Create one with create_task if needed.`, { tasks: [], total: 0 });
+            const shown = matches.slice(0, input.limit);
+            const lines = shown.map((task) => {
+                const parent = task.parentId === null ? null : store.findTask(task.parentId);
+                return `- ${taskKey(store, task)} [${task.status}, ${task.priority}${task.type === "test" ? ", test" : ""}] ${task.title}${parent ? ` (under ${taskKey(store, parent)})` : ""}`;
+            });
+            const more = matches.length > shown.length ? `\n(${matches.length - shown.length} more: narrow the query or raise limit)` : "";
+            return respond(SearchTasksDataSchema, `${matches.length} task(s) in "${space.name}":\n${lines.join("\n")}${more}`, {
+                tasks: shown.map((task) => taskData(store, task)),
+                total: matches.length,
+            });
+        },
+    },
+    {
+        method: "POST",
+        path: "/tasks",
+        handle: ({ store }, { agent, body }) => {
+            const input = parseInput(CreateTaskBodySchema, body);
+            const title = requireText(input.title, "title");
+            const { parent, task } = actFor(store, agent, input.request_id, (tx, space) => {
+                const parent = input.parent === undefined ? null : resolveTask(tx.store, space, input.parent);
+                const created = tx.createTask({
+                    spaceId: space.id,
+                    parentId: parent?.id ?? null,
+                    title,
+                    description: input.description,
+                    type: input.type,
+                    priority: input.priority,
+                    status: input.status,
+                });
+                tx.recordAgentAction({
+                    entityType: "task",
+                    entityId: created.id,
+                    operation: "create",
+                    before: null,
+                    after: tx.store.taskSnapshot(created.id),
+                    summary: createdTaskSummary(tx.store, created),
+                    taskId: created.id,
+                });
+                return { parent, task: created };
+            });
+            return respond(TaskDataSchema, `Created ${taskKey(store, task)} "${task.title}" [${task.status}, ${task.priority}, ${task.type}]${parent ? ` under ${taskKey(store, parent)}` : ""} (id ${task.id}).`, { task: taskData(store, store.getTask(task.id)) });
+        },
+    },
+    {
+        method: "PATCH",
+        path: "/tasks/:ref",
+        handle: ({ store }, { agent, params, body }) => {
+            const input = parseInput(UpdateTaskBodySchema, body);
+            const { title, description, status, priority, type, parent, after_task, tested_task_id } = input;
+            const { task, summary } = actFor(store, agent, input.request_id, (tx, space) => {
+                if ([title, description, status, priority, type, parent, after_task, tested_task_id].every((value) => value === undefined)) {
+                    throw new OrganizerError("Nothing to change: give at least one of title, description, status, priority, type, parent, after_task or tested_task_id.");
+                }
+                const patch = {};
+                if (title !== undefined)
+                    patch.title = requireText(title, "title");
+                if (description !== undefined)
+                    patch.description = description;
+                if (status !== undefined)
+                    patch.status = status;
+                if (priority !== undefined)
+                    patch.priority = priority;
+                if (type !== undefined)
+                    patch.type = type;
+                const task = resolveTask(tx.store, space, params.ref);
+                if (parent !== undefined)
+                    patch.parentId = parent === null ? null : resolveTask(tx.store, space, parent).id;
+                if (tested_task_id !== undefined)
+                    patch.testedTaskId = tested_task_id === null ? null : resolveTask(tx.store, space, tested_task_id).id;
+                const afterId = after_task === undefined ? undefined : after_task === null ? null : resolveTask(tx.store, space, after_task).id;
+                const before = tx.store.taskSnapshot(task.id);
+                const updated = Object.keys(patch).length > 0 ? tx.updateTask(task.id, patch) : task;
+                if (afterId !== undefined)
+                    tx.moveTask(task.id, updated.status, afterId);
+                const after = tx.store.taskSnapshot(task.id);
+                const { summary, operation } = taskUpdateSummary(tx.store, before, after);
+                tx.recordAgentAction({ entityType: "task", entityId: task.id, operation, before, after, summary, taskId: task.id });
+                return { task, summary };
+            });
+            const updated = store.getTask(task.id);
+            return respond(TaskDataSchema, `Updated ${taskKey(store, updated)} "${updated.title}" [${updated.status}, ${updated.priority}, ${updated.type}]: ${summary}.`, {
+                task: taskData(store, updated),
+            });
+        },
+    },
+    {
+        method: "PUT",
+        path: "/tasks/:ref/assignees",
+        handle: ({ store }, { agent, params, body }) => {
+            const input = parseInput(SetAssigneesBodySchema, body);
+            const { task, users } = actFor(store, agent, input.request_id, (tx, space) => {
+                const task = resolveTask(tx.store, space, params.ref);
+                const users = resolveMembers(tx.store, space, input.assignees);
+                const before = tx.store.taskSnapshot(task.id);
+                tx.setAssignees(task.id, users.map((user) => user.id));
+                const after = tx.store.taskSnapshot(task.id);
+                tx.recordAgentAction({
+                    entityType: "task",
+                    entityId: task.id,
+                    operation: "assign",
+                    before,
+                    after,
+                    summary: assigneesSummary(tx.store, before.assigneeIds, after.assigneeIds, task.type === "test"),
+                    taskId: task.id,
+                });
+                return { task, users };
+            });
+            const names = users.map(userLabel);
+            return respond(TaskDataSchema, `${taskKey(store, task)} is now assigned to ${names.length > 0 ? names.join(", ") : "nobody"}.`, { task: taskData(store, store.getTask(task.id)) });
+        },
+    },
+    {
+        method: "PUT",
+        path: "/tasks/:ref/tags",
+        handle: ({ store }, { agent, params, body }) => {
+            const input = parseInput(SetTagsBodySchema, body);
+            const { task, tags } = actFor(store, agent, input.request_id, (tx, space) => {
+                const task = resolveTask(tx.store, space, params.ref);
+                const before = tx.store.taskSnapshot(task.id);
+                const tags = tx.setTags(task.id, input.tags);
+                tx.recordAgentAction({
+                    entityType: "task",
+                    entityId: task.id,
+                    operation: "update",
+                    before,
+                    after: tx.store.taskSnapshot(task.id),
+                    summary: tags.length > 0 ? `Tags : ${tags.map((tag) => tag.name).join(", ")}` : "Tags retirés",
+                    taskId: task.id,
+                });
+                return { task, tags };
+            });
+            return respond(TaskDataSchema, `${taskKey(store, task)} tags: ${tags.length > 0 ? tags.map((tag) => tag.name).join(", ") : "none"}.`, {
+                task: taskData(store, store.getTask(task.id)),
+            });
+        },
+    },
+    {
+        method: "POST",
+        path: "/tasks/:ref/comments",
+        handle: ({ store }, { agent, params, body }) => {
+            const input = parseInput(AddCommentBodySchema, body);
+            const text = requireText(input.body, "body");
+            const { task, comment } = actFor(store, agent, input.request_id, (tx, space) => {
+                const task = resolveTask(tx.store, space, params.ref);
+                const comment = tx.addComment(task.id, text);
+                tx.recordAgentAction({ entityType: "comment", entityId: comment.id, operation: "create", before: null, after: comment, summary: "Commentaire ajouté", taskId: task.id });
+                return { task, comment };
+            });
+            return respond(CommentDataSchema, `Commented on ${taskKey(store, task)} (comment id ${comment.id}).`, { task: taskData(store, task), commentId: comment.id });
+        },
+    },
+];

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

@@ -0,0 +1,41 @@
+import type { z } from "zod";
+import type { AgentCaller } from "../core/agent.js";
+import type { Store } from "../core/store.js";
+/** Dépendances de l'API agent. */
+export interface AgentApiContext {
+    store: Store;
+    /** Horloge, imposée par les tests. */
+    now?: () => Date;
+}
+/** Requête `/api/agent/*`, telle que le serveur web la transmet au routeur. */
+export interface AgentApiRequest {
+    method: string;
+    /** Chemin sous `/api/agent`, par exemple `/requests`. */
+    path: string;
+    query: Record<string, string>;
+    body?: unknown;
+    /** Jeton de l'en-tête `Authorization: Bearer`, null sans en-tête. */
+    bearer: string | null;
+}
+/** Réponse réussie : texte rédigé pour l'agent et données structurées. */
+export interface AgentApiResponse {
+    text: string;
+    data: unknown;
+}
+/** Appel d'une route : agent authentifié, paramètres de chemin, requête et corps. */
+export interface AgentCall {
+    agent: AgentCaller;
+    params: Record<string, string>;
+    query: Record<string, string>;
+    body: unknown;
+}
+export interface AgentRoute {
+    method: "GET" | "POST" | "PUT" | "PATCH";
+    /** Chemin sous `/api/agent`, avec `:nom` pour un paramètre. */
+    path: string;
+    handle: (ctx: AgentApiContext, call: AgentCall) => AgentApiResponse;
+}
+/** Données validées par `schema` ; une donnée invalide est une erreur qui liste les problèmes. */
+export declare function parseInput<S extends z.ZodType>(schema: S, value: unknown): z.infer<S>;
+/** Réponse dont les données sont validées par `schema`. */
+export declare function respond<S extends z.ZodType>(schema: S, text: string, data: z.infer<S>): AgentApiResponse;

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

@@ -0,0 +1,14 @@
+import { OrganizerError } from "../core/errors.js";
+/** Données validées par `schema` ; une donnée invalide est une erreur qui liste les problèmes. */
+export function parseInput(schema, value) {
+    const parsed = schema.safeParse(value ?? {});
+    if (!parsed.success) {
+        const issues = parsed.error.issues.map((issue) => `${issue.path.map(String).join(".") || "arguments"}: ${issue.message}`);
+        throw new OrganizerError(`Invalid arguments — ${issues.join("; ")}. Check the tool's input schema.`);
+    }
+    return parsed.data;
+}
+/** Réponse dont les données sont validées par `schema`. */
+export function respond(schema, text, data) {
+    return { text, data: schema.parse(data) };
+}

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

@@ -0,0 +1,12 @@
+/** Suffixe du dossier des pièces jointes, à côté du fichier de la base. */
+export declare const ATTACHMENTS_BACKUP_SUFFIX = ".attachments";
+/** Résultat d'une sauvegarde. */
+export interface BackupResult {
+    databaseFile: string;
+    attachmentsDir: string;
+    attachmentCount: number;
+}
+/** Sauvegarde la base de `dataDir` dans `target`, et ses pièces jointes à côté. */
+export declare function backupSite(dataDir: string, target: string, force: boolean): Promise<BackupResult>;
+/** Exécute la commande ; renvoie le code de sortie du processus. */
+export declare function runBackup(argv: readonly string[], dataDir: string): Promise<number>;