@imenam/mcp-organizer 1.0.2 → 1.0.3

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

@@ -742,7 +742,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 +767,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

@@ -179,12 +179,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/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/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/mcp/notifications.d.ts

@@ -1,13 +1,30 @@
+import { type AgentRequestSummary } from "../../shared/schemas/agent-tools.schema.js";
 import type { OrganizerSiteClient, SiteConnection } from "./client.js";
-import type { ToolDefinition } from "./tools.js";
+import { type ToolDefinition } from "./tools.js";
 /**
- * Outil `enable_notifications`, exécuté par le mode MCP lui-même : il lit le
- * jeton, l'espace et l'état du veilleur sur le site, dépose le relais du
- * veilleur et rend l'appel `Monitor` que l'agent doit faire.
+ * Outils de notification, exécutés par le mode MCP lui-même.
+ *
+ * `enable_notifications` fonctionne de deux façons. En local, il dépose le
+ * relais du veilleur et rend l'appel `Monitor` qui lance `--watch`. Derrière
+ * le relais de mcp-http-gateway, qui remplit l'argument réservé
+ * `_gateway_watch`, il rend une spécification de veille
+ * (`_meta["gateway/watch"]`) : le relais lance alors son propre veilleur, qui
+ * appelle `wait_for_requests` en boucle à travers la gateway.
  */
+/** Clés de la convention de veille de mcp-http-gateway (voir son gateway-watch.js). */
+export declare const WATCH_ARG = "_gateway_watch";
+/** Résultat d'un outil de notification : texte pour l'agent et métadonnées pour le relais. */
+export interface NotificationToolResult {
+    text: string;
+    meta?: Record<string, unknown>;
+}
+/** Ligne d'une demande : une seule ligne, lisible telle quelle dans la notification. */
+export declare function formatRequestEvent(request: AgentRequestSummary): string;
 /** Durée maximale d'un `Monitor` côté hôte. */
 export declare const MONITOR_TIMEOUT_MS = 1800000;
 export declare const ENABLE_NOTIFICATIONS_TOOL: ToolDefinition;
+export declare const WAIT_FOR_REQUESTS_TOOL: ToolDefinition;
 /** Commande du veilleur du jeton `tokenId`. */
 export declare function watchCommand(tokenId: string): string;
-export declare function enableNotifications(client: OrganizerSiteClient, connection: SiteConnection): Promise<string>;
+export declare function enableNotifications(client: OrganizerSiteClient, connection: SiteConnection, args: Record<string, unknown>): Promise<NotificationToolResult>;
+export declare function waitForRequests(client: OrganizerSiteClient, args: Record<string, unknown>): Promise<NotificationToolResult>;

package/dist/src/mcp/notifications.js

@@ -1,35 +1,100 @@
-import { NotificationsDataSchema } from "../../shared/schemas/agent-tools.schema.js";
+import { MAX_WAIT_SECONDS, NotificationsDataSchema } from "../../shared/schemas/agent-tools.schema.js";
+import { ToolArgumentError } from "./tools.js";
 import { writeHandoff } from "./watch-handoff.js";
 /**
- * Outil `enable_notifications`, exécuté par le mode MCP lui-même : il lit le
- * jeton, l'espace et l'état du veilleur sur le site, dépose le relais du
- * veilleur et rend l'appel `Monitor` que l'agent doit faire.
+ * Outils de notification, exécutés par le mode MCP lui-même.
+ *
+ * `enable_notifications` fonctionne de deux façons. En local, il dépose le
+ * relais du veilleur et rend l'appel `Monitor` qui lance `--watch`. Derrière
+ * le relais de mcp-http-gateway, qui remplit l'argument réservé
+ * `_gateway_watch`, il rend une spécification de veille
+ * (`_meta["gateway/watch"]`) : le relais lance alors son propre veilleur, qui
+ * appelle `wait_for_requests` en boucle à travers la gateway.
  */
+/** Clés de la convention de veille de mcp-http-gateway (voir son gateway-watch.js). */
+export const WATCH_ARG = "_gateway_watch";
+const WATCH_META = "gateway/watch";
+const EVENTS_META = "gateway/events";
+/** Longueur maximale de l'extrait du texte d'une demande dans sa ligne. */
+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})`;
+}
 /** Durée maximale d'un `Monitor` côté hôte. */
 export const MONITOR_TIMEOUT_MS = 1_800_000;
 const PACKAGE_NAME = "@imenam/mcp-organizer";
 export const ENABLE_NOTIFICATIONS_TOOL = {
     name: "enable_notifications",
     description: "Get notified in real time of the requests the members of your space send to the AI, without polling the queue. Returns immediately: it blocks nothing and starts nothing on its own. It hands you the exact Monitor call to make right after — arming that watcher is what actually delivers notifications, and until you do it no request will reach you. Call this once at the start of a session; then keep working, each new pending request interrupts you on its own. The host stops the watcher after 30 minutes at most: re-arm it with the same Monitor call each time it expires.",
-    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    inputSchema: {
+        type: "object",
+        properties: {
+            [WATCH_ARG]: {
+                type: "object",
+                description: "Filled in by the mcp-http-gateway relay, never by the agent: the relay will run the watcher and needs a watch specification instead of a local command.",
+            },
+        },
+        additionalProperties: false,
+    },
+};
+export const WAIT_FOR_REQUESTS_TOOL = {
+    name: "wait_for_requests",
+    description: "Block until at least one request of your space becomes pending (created, or released by a member), or until the timeout. Returns the new pending requests (none on timeout) and a cursor: pass it to the next call to get exactly what became pending since. It is the waiting tool of the notification watcher; to stay reachable, prefer enable_notifications.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            cursor: {
+                type: "string",
+                description: "Cursor returned by the previous call. Without it, only requests that become pending after the call starts are returned.",
+            },
+            timeout_seconds: { type: "integer", minimum: 1, maximum: MAX_WAIT_SECONDS, description: `Maximum wait, in seconds (1-${MAX_WAIT_SECONDS}, defaults to 30).` },
+            watcher: {
+                type: "boolean",
+                description: "Set by the notification watcher: the wait counts as the presence of this token's watcher, shown as listening in the web app.",
+            },
+        },
+        additionalProperties: false,
+    },
 };
 /** Commande du veilleur du jeton `tokenId`. */
 export function watchCommand(tokenId) {
     return `npx -y ${PACKAGE_NAME} --watch ${tokenId}`;
 }
-export async function enableNotifications(client, connection) {
+export async function enableNotifications(client, connection, args) {
+    for (const name of Object.keys(args)) {
+        if (name !== WATCH_ARG)
+            throw new ToolArgumentError(`Invalid arguments — ${name}: enable_notifications takes no argument.`);
+    }
     const envelope = await client.envelope({ method: "GET", path: "notifications", query: {}, body: undefined });
-    const { token, space, pendingCount, watcher } = client.parseData(NotificationsDataSchema, envelope.data);
+    const { token, space, pendingCount, watcher, cursor } = client.parseData(NotificationsDataSchema, envelope.data);
+    if (args[WATCH_ARG] !== undefined) {
+        return {
+            text: `Watch specification for the mcp-http-gateway relay: requests of space "${space.name}" for token "${token.name}".`,
+            meta: {
+                [WATCH_META]: {
+                    tool: WAIT_FOR_REQUESTS_TOOL.name,
+                    arguments: { watcher: true },
+                    cursor,
+                    description: "New requests for the AI in the organizer",
+                },
+            },
+        };
+    }
     writeHandoff({ tokenId: token.id, url: connection.url, token: connection.token });
     const command = watchCommand(token.id);
     if (watcher.armed) {
-        return [
+        const text = [
             `Notifications are already live for token "${token.name}" on space "${space.name}" (watcher armed since ${watcher.since}).`,
             "Nothing to do: keep working, new requests will interrupt you on their own.",
             "Do not arm a second watcher — you would get every request twice.",
             "Only exception: if the host just told you your watcher expired or stopped, re-arm it",
             `with the same Monitor call (command \`${command}\`, timeout_ms ${MONITOR_TIMEOUT_MS}).`,
         ].join("\n");
+        return { text };
     }
     const lines = [
         `Notifications enabled for token "${token.name}" on space "${space.name}".`,
@@ -50,5 +115,26 @@ export async function enableNotifications(client, connection) {
     if (pendingCount > 0) {
         lines.push("", `${pendingCount} request(s) are already pending. Only requests that become pending AFTER the`, "watcher starts are announced — process the backlog with list_requests.");
     }
-    return lines.join("\n");
+    return { text: lines.join("\n") };
+}
+export async function waitForRequests(client, args) {
+    for (const name of Object.keys(args)) {
+        if (!(name in WAIT_FOR_REQUESTS_TOOL.inputSchema.properties))
+            throw new ToolArgumentError(`Invalid arguments — ${name}: unknown argument. Check the tool's input schema.`);
+    }
+    const { cursor, timeout_seconds: timeout, watcher } = args;
+    if (cursor !== undefined && typeof cursor !== "string")
+        throw new ToolArgumentError("Invalid arguments — cursor: expected the string returned by the previous call.");
+    if (timeout !== undefined && (typeof timeout !== "number" || !Number.isInteger(timeout) || timeout < 1 || timeout > MAX_WAIT_SECONDS)) {
+        throw new ToolArgumentError(`Invalid arguments — timeout_seconds: expected an integer from 1 to ${MAX_WAIT_SECONDS}.`);
+    }
+    if (watcher !== undefined && typeof watcher !== "boolean")
+        throw new ToolArgumentError("Invalid arguments — watcher: expected a boolean.");
+    const seconds = timeout ?? 30;
+    const result = await client.waitForRequests({ timeout_seconds: seconds, since: cursor, watcher: watcher === true });
+    const lines = result.requests.map(formatRequestEvent);
+    const text = lines.length === 0
+        ? `No new pending request in "${result.space.name}" after ${seconds}s. Cursor: ${result.cursor}`
+        : `${lines.length} new pending request(s) in "${result.space.name}":\n${lines.join("\n")}\nCursor: ${result.cursor}\n\nNext: call claim_request with the id of the oldest request.`;
+    return { text, meta: { [EVENTS_META]: { cursor: result.cursor, lines } } };
 }

package/dist/src/mcp/start.d.ts

@@ -1,6 +1,6 @@
 import { type SiteConnection } from "./client.js";
 /** Présentation du serveur transmise au client MCP : concepts et déroulé. */
-export declare const INSTRUCTIONS = "mcp-organizer connects you to an organizer site: a multi-user task manager where people organize tasks in a web app and queue requests for the AI. You, the connected agent, process those requests when the user asks you to. The site never calls an LLM: you are the intelligence.\n\nYour token covers exactly one space, with the rights of the user who created the token. Every tool works on that space.\n\nConcepts:\n- A **space** holds tasks and an idea box. A user's **personal space** is private; a **shared space** has one owner and members.\n- A **task** has a title, a markdown description, a status (todo, doing, review, done), a priority (low, medium, high, critical), assignees and tags. Tasks nest on two levels: task > sub-task > sub-sub-task. A task is either standard (with a checklist) or a test (with checkpoints that each tester marks ok, ko, blocked or untested).\n- A **request** is something a member of your space asked the AI: an idea, a remark, a test review, a message or an idea promotion. It is pending, then processing once you claim it (only your token can then act for it), then done (with your reply) or failed (with the reason).\n- A **batch** is the set of actions you perform for one request. Every action is logged with its before and after state and with your token, and users can undo one action or the whole batch.\n- The **scope** of your work is the space of your token: you see and process the requests of all its members, and you never act outside it.\n\nWork loop, when the user asks you to process the queue:\n1. list_requests to see the pending requests of your space.\n2. claim_request on the oldest one: it becomes processing for you and you get its context (text, author, context task, task tree, members, recent ideas). get_context shows the space at any time.\n3. Read what you need with get_task and search_tasks.\n4. Act with create_task, update_task, set_assignees, set_tags, edit_checklist, add_comment, create_idea, update_idea, promote_idea \u2014 always passing the request_id. Each write is one undoable action of the batch.\n5. complete_request with a short reply in the author's language (or fail_request with the reason), then go back to step 1 until no request is pending.\nWhen the queue is empty, tell the user.\n\nNotifications: call enable_notifications once at the start of the session and arm the watcher it hands you with Monitor. Each request that becomes pending in your space then arrives on its own as one line (kind, author, excerpt, request id), even while you are idle: process it with the work loop above, starting with claim_request. The host stops that watcher after 30 minutes at most: each time it tells you the watcher expired, re-arm it at once with the same Monitor call; otherwise notifications stop for good. A line \"notifications stopped\" means the site refused the token: tell the user.\n\nHow to handle each kind of request:\n- **idea**: classify it. If it belongs to an existing task or sub-task, attach it there (sub-task, checklist item or comment). If it is actionable and important enough, create a task (or sub-task) with a fitting priority. Otherwise, put it in the idea box with create_idea. Prefer existing tasks over duplicates.\n- **test_review**: feed the tester's findings back into the existing tasks (status, checklist, comments, priority of the affected tasks), or create a task for each problem that has none.\n- **remark** and **message**: do whatever is useful \u2014 answer, update or create tasks, comment \u2014 and say what you did in the reply.\n- **idea_promotion**: turn the context idea into a well-formed task with promote_idea.\n\nRules: write titles, descriptions and replies in the language of the users; keep the reply short and factual. Errors tell you what to do next; an error about the token (missing, revoked, expired, owner no longer a member) cannot be fixed by retrying: tell the user.";
+export declare const INSTRUCTIONS = "mcp-organizer connects you to an organizer site: a multi-user task manager where people organize tasks in a web app and queue requests for the AI. You, the connected agent, process those requests when the user asks you to. The site never calls an LLM: you are the intelligence.\n\nYour token covers exactly one space, with the rights of the user who created the token. Every tool works on that space.\n\nConcepts:\n- A **space** holds tasks and an idea box. A user's **personal space** is private; a **shared space** has one owner and members.\n- A **task** has a title, a markdown description, a status (todo, doing, review, done), a priority (low, medium, high, critical), assignees and tags. Tasks nest on two levels: task > sub-task > sub-sub-task. A task is either standard (with a checklist) or a test (with checkpoints that each tester marks ok, ko, blocked or untested).\n- A **request** is something a member of your space asked the AI: an idea, a remark, a test review, a message or an idea promotion. It is pending, then processing once you claim it (only your token can then act for it), then done (with your reply) or failed (with the reason).\n- A **batch** is the set of actions you perform for one request. Every action is logged with its before and after state and with your token, and users can undo one action or the whole batch.\n- The **scope** of your work is the space of your token: you see and process the requests of all its members, and you never act outside it.\n\nWork loop, when the user asks you to process the queue:\n1. list_requests to see the pending requests of your space.\n2. claim_request on the oldest one: it becomes processing for you and you get its context (text, author, context task, task tree, members, recent ideas). get_context shows the space at any time.\n3. Read what you need with get_task and search_tasks.\n4. Act with create_task, update_task, set_assignees, set_tags, edit_checklist, add_comment, create_idea, update_idea, promote_idea \u2014 always passing the request_id. Each write is one undoable action of the batch.\n5. complete_request with a short reply in the author's language (or fail_request with the reason), then go back to step 1 until no request is pending.\nWhen the queue is empty, tell the user.\n\nNotifications: call enable_notifications once at the start of the session and arm the watcher it hands you with Monitor, whatever the command (behind mcp-http-gateway, the gateway relay answers in place of this server and gives its own watcher command). Each request that becomes pending in your space then arrives on its own as one line (kind, author, excerpt, request id), even while you are idle: process it with the work loop above, starting with claim_request. The host stops that watcher after 30 minutes at most: each time it tells you the watcher expired, re-arm it at once with the same Monitor call; otherwise notifications stop for good. A line \"notifications stopped\" means the site refused the token, and a line \"[gateway-watch] \u2026 la veille \u00E9choue\" means the gateway watcher keeps failing: tell the user. wait_for_requests is the waiting tool of the watcher: you do not need to call it.\n\nHow to handle each kind of request:\n- **idea**: classify it. If it belongs to an existing task or sub-task, attach it there (sub-task, checklist item or comment). If it is actionable and important enough, create a task (or sub-task) with a fitting priority. Otherwise, put it in the idea box with create_idea. Prefer existing tasks over duplicates.\n- **test_review**: feed the tester's findings back into the existing tasks (status, checklist, comments, priority of the affected tasks), or create a task for each problem that has none.\n- **remark** and **message**: do whatever is useful \u2014 answer, update or create tasks, comment \u2014 and say what you did in the reply.\n- **idea_promotion**: turn the context idea into a well-formed task with promote_idea.\n\nRules: write titles, descriptions and replies in the language of the users; keep the reply short and factual. Errors tell you what to do next; an error about the token (missing, revoked, expired, owner no longer a member) cannot be fixed by retrying: tell the user.";
 /**
  * Connexion au site d'après `ORGANIZER_URL` et `ORGANIZER_TOKEN` ; une valeur
  * absente ou invalide, ou une URL http vers une autre machine, est une `ConfigError`.

package/dist/src/mcp/start.js

@@ -6,36 +6,36 @@ import { createLogger, setupLogging } from "../core/logger.js";
 import { ConfigError } from "../core/errors.js";
 import { OrganizerSiteClient, SiteError } from "./client.js";
 import { AGENT_TOOLS, ToolArgumentError, findAgentTool, toolHttpRequest } from "./tools.js";
-import { ENABLE_NOTIFICATIONS_TOOL, enableNotifications } from "./notifications.js";
+import { ENABLE_NOTIFICATIONS_TOOL, WAIT_FOR_REQUESTS_TOOL, enableNotifications, waitForRequests } from "./notifications.js";
 import { removeOwnHandoffs } from "./watch-handoff.js";
 /** Présentation du serveur transmise au client MCP : concepts et déroulé. */
-export const INSTRUCTIONS = `mcp-organizer connects you to an organizer site: a multi-user task manager where people organize tasks in a web app and queue requests for the AI. You, the connected agent, process those requests when the user asks you to. The site never calls an LLM: you are the intelligence.
-
-Your token covers exactly one space, with the rights of the user who created the token. Every tool works on that space.
-
-Concepts:
-- A **space** holds tasks and an idea box. A user's **personal space** is private; a **shared space** has one owner and members.
-- A **task** has a title, a markdown description, a status (todo, doing, review, done), a priority (low, medium, high, critical), assignees and tags. Tasks nest on two levels: task > sub-task > sub-sub-task. A task is either standard (with a checklist) or a test (with checkpoints that each tester marks ok, ko, blocked or untested).
-- A **request** is something a member of your space asked the AI: an idea, a remark, a test review, a message or an idea promotion. It is pending, then processing once you claim it (only your token can then act for it), then done (with your reply) or failed (with the reason).
-- A **batch** is the set of actions you perform for one request. Every action is logged with its before and after state and with your token, and users can undo one action or the whole batch.
-- The **scope** of your work is the space of your token: you see and process the requests of all its members, and you never act outside it.
-
-Work loop, when the user asks you to process the queue:
-1. list_requests to see the pending requests of your space.
-2. claim_request on the oldest one: it becomes processing for you and you get its context (text, author, context task, task tree, members, recent ideas). get_context shows the space at any time.
-3. Read what you need with get_task and search_tasks.
-4. Act with create_task, update_task, set_assignees, set_tags, edit_checklist, add_comment, create_idea, update_idea, promote_idea — always passing the request_id. Each write is one undoable action of the batch.
-5. complete_request with a short reply in the author's language (or fail_request with the reason), then go back to step 1 until no request is pending.
-When the queue is empty, tell the user.
-
-Notifications: call enable_notifications once at the start of the session and arm the watcher it hands you with Monitor. Each request that becomes pending in your space then arrives on its own as one line (kind, author, excerpt, request id), even while you are idle: process it with the work loop above, starting with claim_request. The host stops that watcher after 30 minutes at most: each time it tells you the watcher expired, re-arm it at once with the same Monitor call; otherwise notifications stop for good. A line "notifications stopped" means the site refused the token: tell the user.
-
-How to handle each kind of request:
-- **idea**: classify it. If it belongs to an existing task or sub-task, attach it there (sub-task, checklist item or comment). If it is actionable and important enough, create a task (or sub-task) with a fitting priority. Otherwise, put it in the idea box with create_idea. Prefer existing tasks over duplicates.
-- **test_review**: feed the tester's findings back into the existing tasks (status, checklist, comments, priority of the affected tasks), or create a task for each problem that has none.
-- **remark** and **message**: do whatever is useful — answer, update or create tasks, comment — and say what you did in the reply.
-- **idea_promotion**: turn the context idea into a well-formed task with promote_idea.
-
+export const INSTRUCTIONS = `mcp-organizer connects you to an organizer site: a multi-user task manager where people organize tasks in a web app and queue requests for the AI. You, the connected agent, process those requests when the user asks you to. The site never calls an LLM: you are the intelligence.
+
+Your token covers exactly one space, with the rights of the user who created the token. Every tool works on that space.
+
+Concepts:
+- A **space** holds tasks and an idea box. A user's **personal space** is private; a **shared space** has one owner and members.
+- A **task** has a title, a markdown description, a status (todo, doing, review, done), a priority (low, medium, high, critical), assignees and tags. Tasks nest on two levels: task > sub-task > sub-sub-task. A task is either standard (with a checklist) or a test (with checkpoints that each tester marks ok, ko, blocked or untested).
+- A **request** is something a member of your space asked the AI: an idea, a remark, a test review, a message or an idea promotion. It is pending, then processing once you claim it (only your token can then act for it), then done (with your reply) or failed (with the reason).
+- A **batch** is the set of actions you perform for one request. Every action is logged with its before and after state and with your token, and users can undo one action or the whole batch.
+- The **scope** of your work is the space of your token: you see and process the requests of all its members, and you never act outside it.
+
+Work loop, when the user asks you to process the queue:
+1. list_requests to see the pending requests of your space.
+2. claim_request on the oldest one: it becomes processing for you and you get its context (text, author, context task, task tree, members, recent ideas). get_context shows the space at any time.
+3. Read what you need with get_task and search_tasks.
+4. Act with create_task, update_task, set_assignees, set_tags, edit_checklist, add_comment, create_idea, update_idea, promote_idea — always passing the request_id. Each write is one undoable action of the batch.
+5. complete_request with a short reply in the author's language (or fail_request with the reason), then go back to step 1 until no request is pending.
+When the queue is empty, tell the user.
+
+Notifications: call enable_notifications once at the start of the session and arm the watcher it hands you with Monitor, whatever the command (behind mcp-http-gateway, the gateway relay answers in place of this server and gives its own watcher command). Each request that becomes pending in your space then arrives on its own as one line (kind, author, excerpt, request id), even while you are idle: process it with the work loop above, starting with claim_request. The host stops that watcher after 30 minutes at most: each time it tells you the watcher expired, re-arm it at once with the same Monitor call; otherwise notifications stop for good. A line "notifications stopped" means the site refused the token, and a line "[gateway-watch] … la veille échoue" means the gateway watcher keeps failing: tell the user. wait_for_requests is the waiting tool of the watcher: you do not need to call it.
+
+How to handle each kind of request:
+- **idea**: classify it. If it belongs to an existing task or sub-task, attach it there (sub-task, checklist item or comment). If it is actionable and important enough, create a task (or sub-task) with a fitting priority. Otherwise, put it in the idea box with create_idea. Prefer existing tasks over duplicates.
+- **test_review**: feed the tester's findings back into the existing tasks (status, checklist, comments, priority of the affected tasks), or create a task for each problem that has none.
+- **remark** and **message**: do whatever is useful — answer, update or create tasks, comment — and say what you did in the reply.
+- **idea_promotion**: turn the context idea into a well-formed task with promote_idea.
+
 Rules: write titles, descriptions and replies in the language of the users; keep the reply short and factual. Errors tell you what to do next; an error about the token (missing, revoked, expired, owner no longer a member) cannot be fixed by retrying: tell the user.`;
 /** Hôtes de la machine locale, seuls admis en http. */
 const LOCAL_HOSTNAMES = new Set(["localhost", "127.0.0.1", "[::1]"]);
@@ -84,15 +84,22 @@ export async function runMcpMode() {
     const logger = createLogger("mcp");
     const client = new OrganizerSiteClient(connection);
     const server = new Server({ name: "mcp-organizer", version: APP_VERSION }, { capabilities: { tools: {} }, instructions: INSTRUCTIONS });
-    server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: [...AGENT_TOOLS.map((tool) => tool.definition), ENABLE_NOTIFICATIONS_TOOL] }));
+    // Outils exécutés par le mode MCP lui-même : leur résultat peut porter des métadonnées pour le relais de mcp-http-gateway.
+    const notificationTools = {
+        [ENABLE_NOTIFICATIONS_TOOL.name]: (args) => enableNotifications(client, connection, args),
+        [WAIT_FOR_REQUESTS_TOOL.name]: (args) => waitForRequests(client, args),
+    };
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: [...AGENT_TOOLS.map((tool) => tool.definition), ENABLE_NOTIFICATIONS_TOOL, WAIT_FOR_REQUESTS_TOOL] }));
     server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const { name, arguments: args } = request.params;
-        if (name === ENABLE_NOTIFICATIONS_TOOL.name) {
+        const notificationTool = notificationTools[name];
+        if (notificationTool) {
             try {
-                return { content: [{ type: "text", text: await enableNotifications(client, connection) }] };
+                const result = await notificationTool((args ?? {}));
+                return { content: [{ type: "text", text: result.text }], ...(result.meta ? { _meta: result.meta } : {}) };
             }
             catch (error) {
-                if (!(error instanceof SiteError))
+                if (!(error instanceof SiteError) && !(error instanceof ToolArgumentError))
                     logger.error(`Tool ${name} failed: ${error?.stack ?? error}`);
                 return errorResult(error?.message ?? String(error));
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@imenam/mcp-organizer",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "MCP server with a multi-user web GUI to organize tasks in personal and shared spaces; requests to the AI are queued and processed by the connected agent, every agent action is logged and undoable.",
   "main": "dist/src/index.js",
   "scripts": {