@imenam/mcp-organizer 1.0.1 → 1.0.2

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

@@ -234,6 +234,7 @@ export declare const RequestListResponseSchema: z.ZodObject<{
         name: z.ZodString;
         ownerName: z.ZodString;
         lastUsedAt: z.ZodNullable<z.ZodISODateTime>;
+        listening: z.ZodBoolean;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type RequestListResponse = z.infer<typeof RequestListResponseSchema>;

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

@@ -75,8 +75,11 @@ export const RequestListResponseSchema = z.object({
     /** Demandes de l'espace, de la plus récente à la plus ancienne. */
     requests: z.array(RequestViewSchema),
     pendingCount: z.number().int().min(0),
-    /** Jetons actifs qui couvrent l'espace, du plus récemment utilisé au moins récemment. */
-    agents: z.array(AgentRefSchema.extend({ lastUsedAt: TimestampSchema.nullable() })),
+    /**
+     * Jetons actifs qui couvrent l'espace, du plus récemment utilisé au moins
+     * récemment ; `listening` : un veilleur de notifications de ce jeton est armé.
+     */
+    agents: z.array(AgentRefSchema.extend({ lastUsedAt: TimestampSchema.nullable(), listening: z.boolean() })),
 });
 /** Version d'une tâche dans son historique. */
 export const TaskVersionViewSchema = z.object({

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

@@ -25,6 +25,20 @@ export declare const ListRequestsQuerySchema: z.ZodObject<{
     }>>;
     limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
 }, z.core.$strict>;
+/** Durée maximale d'une attente longue de `GET requests/wait`, en secondes. */
+export declare const MAX_WAIT_SECONDS = 50;
+/**
+ * `GET requests/wait` : durée de l'attente ; `since`, curseur rendu par
+ * l'attente précédente (les demandes passées en attente depuis sont rendues
+ * aussitôt) ; `watcher=true` pour un veilleur de notifications.
+ */
+export declare const WaitRequestsQuerySchema: z.ZodObject<{
+    timeout_seconds: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    since: z.ZodOptional<z.ZodISODateTime>;
+    watcher: z.ZodOptional<z.ZodEnum<{
+        true: "true";
+    }>>;
+}, z.core.$strict>;
 /** `POST requests/:id/claim` : sans corps. */
 export declare const ClaimRequestBodySchema: z.ZodObject<{}, z.core.$strict>;
 export declare const CompleteRequestBodySchema: z.ZodObject<{
@@ -722,3 +736,83 @@ export declare const PromoteIdeaDataSchema: z.ZodObject<{
         tags: z.ZodArray<z.ZodString>;
     }, z.core.$strip>;
 }, z.core.$strip>;
+/** Présence d'un veilleur de notifications pour le jeton. */
+export declare const AgentWatcherSchema: z.ZodObject<{
+    armed: z.ZodBoolean;
+    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. */
+export declare const NotificationsDataSchema: z.ZodObject<{
+    token: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>;
+    space: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        kind: z.ZodEnum<{
+            personal: "personal";
+            shared: "shared";
+        }>;
+        keyPrefix: z.ZodString;
+    }, z.core.$strip>;
+    pendingCount: z.ZodNumber;
+    watcher: z.ZodObject<{
+        armed: z.ZodBoolean;
+        since: z.ZodNullable<z.ZodISODateTime>;
+        lastSeen: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * `GET requests/wait` : demandes passées en attente (vide à l'expiration) et
+ * curseur à repasser en `since` à l'attente suivante.
+ */
+export declare const WaitRequestsDataSchema: z.ZodObject<{
+    space: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        kind: z.ZodEnum<{
+            personal: "personal";
+            shared: "shared";
+        }>;
+        keyPrefix: z.ZodString;
+    }, z.core.$strip>;
+    requests: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            idea: "idea";
+            idea_promotion: "idea_promotion";
+            message: "message";
+            remark: "remark";
+            test_review: "test_review";
+        }>;
+        status: z.ZodEnum<{
+            cancelled: "cancelled";
+            done: "done";
+            failed: "failed";
+            pending: "pending";
+            processing: "processing";
+        }>;
+        text: z.ZodString;
+        author: z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            email: z.ZodString;
+        }, z.core.$strip>;
+        contextTask: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            key: z.ZodString;
+            title: z.ZodString;
+        }, z.core.$strip>>;
+        contextIdeaId: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodISODateTime;
+        claimedAt: z.ZodNullable<z.ZodISODateTime>;
+        claimedByThisToken: z.ZodBoolean;
+        reply: z.ZodNullable<z.ZodString>;
+        failureReason: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    cursor: z.ZodISODateTime;
+    timedOut: z.ZodBoolean;
+}, z.core.$strip>;
+export type WaitRequestsData = z.infer<typeof WaitRequestsDataSchema>;

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

@@ -26,6 +26,20 @@ export const ListRequestsQuerySchema = z
     limit: z.coerce.number().int().min(1).max(MAX_REQUEST_LIST_LIMIT).default(20),
 })
     .strict();
+/** Durée maximale d'une attente longue de `GET requests/wait`, en secondes. */
+export const MAX_WAIT_SECONDS = 50;
+/**
+ * `GET requests/wait` : durée de l'attente ; `since`, curseur rendu par
+ * l'attente précédente (les demandes passées en attente depuis sont rendues
+ * aussitôt) ; `watcher=true` pour un veilleur de notifications.
+ */
+export const WaitRequestsQuerySchema = z
+    .object({
+    timeout_seconds: z.coerce.number().int().min(1).max(MAX_WAIT_SECONDS).default(30),
+    since: TimestampSchema.optional(),
+    watcher: z.enum(["true"]).optional(),
+})
+    .strict();
 /** `POST requests/:id/claim` : sans corps. */
 export const ClaimRequestBodySchema = z.object({}).strict();
 export const CompleteRequestBodySchema = z.object({ reply: z.string().max(MAX_REPLY_LENGTH) }).strict();
@@ -163,3 +177,22 @@ export const ChecklistDataSchema = z.object({
 export const CommentDataSchema = z.object({ task: AgentTaskSummarySchema, commentId: IdSchema });
 export const IdeaDataSchema = z.object({ idea: AgentIdeaSchema });
 export const PromoteIdeaDataSchema = z.object({ idea: AgentIdeaSchema, task: AgentTaskSummarySchema });
+/** Présence d'un veilleur de notifications pour le jeton. */
+export const AgentWatcherSchema = z.object({ armed: z.boolean(), since: TimestampSchema.nullable(), lastSeen: TimestampSchema.nullable() });
+/** `GET notifications` : jeton et espace de l'agent, demandes en attente et veilleur du jeton. */
+export const NotificationsDataSchema = z.object({
+    token: z.object({ id: IdSchema, name: z.string() }),
+    space: AgentSpaceSchema,
+    pendingCount: z.number().int().min(0),
+    watcher: AgentWatcherSchema,
+});
+/**
+ * `GET requests/wait` : demandes passées en attente (vide à l'expiration) et
+ * curseur à repasser en `since` à l'attente suivante.
+ */
+export const WaitRequestsDataSchema = z.object({
+    space: AgentSpaceSchema,
+    requests: z.array(AgentRequestSummarySchema),
+    cursor: TimestampSchema,
+    timedOut: z.boolean(),
+});

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

@@ -0,0 +1,16 @@
+import { type AgentApiContext, type AgentApiRequest, type AgentApiResponse, type AgentRoute } 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 declare const notificationRoutes: AgentRoute[];
+/**
+ * `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 declare function waitForPendingRequests(ctx: AgentApiContext, request: AgentApiRequest, signal: AbortSignal): Promise<AgentApiResponse>;

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/router.js

@@ -2,6 +2,7 @@ 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) {
@@ -12,7 +13,7 @@ function compile(route) {
     });
     return { route, pattern: new RegExp(`^${source}$`), keys };
 }
-const ROUTES = [...requestRoutes, ...taskRoutes, ...checklistRoutes, ...ideaRoutes].map(compile);
+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 {

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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,62 @@
+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 { readHandoff } from "../mcp/watch-handoff.js";
+/**
+ * Mode veilleur (`--watch <identifiant du jeton>`).
+ *
+ * Une ligne sur stdout = une demande passée en attente. Ce flux est consommé
+ * par l'outil `Monitor` de l'hôte, qui réveille la session de l'agent à chaque
+ * ligne, y compris quand elle est inactive. Le journal part sur stderr.
+ *
+ * Une panne réseau ou du site est réessayée avec un délai croissant. Un refus
+ * du site (jeton révoqué, expiré, route inconnue) arrête le veilleur après une
+ * dernière ligne qui en donne la raison.
+ */
+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;
+}
+export async function runWatchMode(tokenId) {
+    if (!tokenId || tokenId.startsWith("--")) {
+        throw new ConfigError("--watch needs the token id given by the enable_notifications tool: `mcp-organizer --watch <token id>`.");
+    }
+    const handoff = readHandoff(tokenId);
+    if (!handoff) {
+        throw new ConfigError(`No notification handoff for token ${tokenId}: call the enable_notifications tool of the organizer MCP server, then arm the watcher with the command it returns.`);
+    }
+    const client = new OrganizerSiteClient({ url: handoff.url, token: handoff.token });
+    process.stderr.write(`watching token ${tokenId} on ${handoff.url}\n`);
+    let since;
+    let backoff = BACKOFF_MIN_MS;
+    for (;;) {
+        try {
+            const result = await client.waitForRequests({ timeout_seconds: MAX_WAIT_SECONDS, since, watcher: true });
+            backoff = BACKOFF_MIN_MS;
+            since = result.cursor;
+            for (const request of result.requests)
+                process.stdout.write(`${formatRequestEvent(request)}\n`);
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            if (isRefusal(error)) {
+                process.stdout.write(`[organizer] notifications stopped: ${detail.replace(/\s+/g, " ")}\n`);
+                return 1;
+            }
+            process.stderr.write(`wait failed, retrying in ${Math.round(backoff / 1000)}s: ${detail}\n`);
+            await new Promise((resolve) => setTimeout(resolve, backoff));
+            backoff = Math.min(backoff * 2, BACKOFF_MAX_MS);
+        }
+    }
+}

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

@@ -40,7 +40,8 @@ export declare function releaseRequest(store: Store, userId: string, requestId:
 export declare function getRequest(store: Store, userId: string, requestId: string): RequestView;
 /**
  * Demandes d'un espace, avec le nombre de demandes en attente et les jetons
- * actifs qui couvrent l'espace, chacun avec son dernier usage.
+ * actifs qui couvrent l'espace, chacun avec son dernier usage et la présence
+ * de son veilleur de notifications.
  */
 export declare function listRequests(store: Store, userId: string, spaceId: string, now?: Date): RequestListResponse;
 /** Annule une action de l'agent. */

package/dist/src/core/requests.js

@@ -190,7 +190,8 @@ export function getRequest(store, userId, requestId) {
 }
 /**
  * Demandes d'un espace, avec le nombre de demandes en attente et les jetons
- * actifs qui couvrent l'espace, chacun avec son dernier usage.
+ * actifs qui couvrent l'espace, chacun avec son dernier usage et la présence
+ * de son veilleur de notifications.
  */
 export function listRequests(store, userId, spaceId, now = new Date()) {
     requireMember(store, spaceId, userId);
@@ -198,7 +199,7 @@ export function listRequests(store, userId, spaceId, now = new Date()) {
     const agents = store
         .listAgentTokensOfSpace(spaceId)
         .filter((token) => tokenState(store, token, now) === "active")
-        .map((token) => ({ ...agentRef(store, token), lastUsedAt: token.lastUsedAt }));
+        .map((token) => ({ ...agentRef(store, token), lastUsedAt: token.lastUsedAt, listening: store.watchers.status(token.id).armed }));
     return { requests, pendingCount: store.countPendingRequestsOfSpace(spaceId), agents };
 }
 // --- Annulation -----------------------------------------------------------------

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

@@ -1,4 +1,5 @@
 import type Database from "better-sqlite3";
+import { WatcherRegistry } from "./watchers.js";
 import { type EntityType, type MemberRole, type RequestKind, type RequestStatus, type SpaceKind, type TaskPriority, type TaskStatus, type TaskType, type TestResultValue, type AccessLinkPurpose, type AgentOperation, type UserStatus, type VersionedEntityType } from "../../shared/schemas/enums.schema.js";
 import { type AccessLink, type AgentAction, type AgentRequest, type AgentToken, type Attachment, type Change, type ChecklistItem, type Comment, type EntityVersion, type Idea, type Invitation, type Membership, type Notification, type Session, type Space, type Tag, type Task, type TaskSnapshot, type TestCheckpoint, type TestResult, type TestReview, type User, type UserSettings } from "../../shared/schemas/entities.schema.js";
 /**
@@ -24,6 +25,9 @@ export declare class Store {
     readonly db: Database.Database;
     private activeMutation;
     private emailListener;
+    private readonly pendingRequestListeners;
+    /** Présence des veilleurs de notifications, par jeton d'agent. */
+    readonly watchers: WatcherRegistry;
     constructor(db: Database.Database);
     /** Ouvre (et migre) la base du répertoire de données. */
     static open(dataDir: string): Store;
@@ -180,6 +184,12 @@ export declare class Store {
      * créées.
      */
     setEmailListener(listener: ((notificationIds: string[]) => void) | null): void;
+    /**
+     * Abonne `listener` aux demandes qui passent en attente (créées, ou
+     * libérées par un membre) : il les reçoit après la validation de la
+     * mutation. La fonction rendue désabonne.
+     */
+    onPendingRequest(listener: (request: AgentRequest) => void): () => void;
     /**
      * Point unique d'écriture. `fn` reçoit une `Mutation` et s'exécute dans une
      * transaction exclusive ; à sa sortie, les invariants sont vérifiés sur l'état
@@ -287,6 +297,8 @@ export declare class Mutation {
     private readonly touched;
     /** Notifications créées par la mutation dont le destinataire veut un e-mail. */
     readonly emailNotificationIds: string[];
+    /** Demandes passées en attente par la mutation : créées, ou libérées. */
+    readonly pendingRequestIds: string[];
     /** Demande pour laquelle agit l'agent, lue au début de la mutation. */
     private readonly request;
     /** Jeton avec lequel agit l'agent. */

package/dist/src/core/store.js

@@ -2,6 +2,7 @@ import { openDatabase } from "./db.js";
 import { ForbiddenError, InvariantError, NotFoundError, OrganizerError } from "./errors.js";
 import { positionBetween } from "../../shared/logic/positions.js";
 import { newId } from "./ids.js";
+import { WatcherRegistry } from "./watchers.js";
 import { MAX_TASK_DEPTH, } from "../../shared/schemas/enums.schema.js";
 import { AccessLinkSchema, AgentActionSchema, AgentTokenSchema, AgentRequestSchema, AttachmentSchema, ChangeSchema, ChecklistItemSchema, CommentSchema, EntityVersionSchema, IdeaSchema, IdeaSnapshotSchema, InvitationSchema, MembershipSchema, NotificationSchema, SessionSchema, SpaceSchema, TagSchema, TaskSchema, TaskSnapshotSchema, TestCheckpointSchema, TestResultSchema, TestReviewSchema, UserSchema, UserSettingsSchema, } from "../../shared/schemas/entities.schema.js";
 /** Valide `value` avec `schema` ; une donnée invalide est une erreur métier qui liste les champs fautifs. */
@@ -276,6 +277,9 @@ export class Store {
     db;
     activeMutation = null;
     emailListener = null;
+    pendingRequestListeners = new Set();
+    /** Présence des veilleurs de notifications, par jeton d'agent. */
+    watchers = new WatcherRegistry();
     constructor(db) {
         this.db = db;
     }
@@ -767,6 +771,15 @@ export class Store {
     setEmailListener(listener) {
         this.emailListener = listener;
     }
+    /**
+     * Abonne `listener` aux demandes qui passent en attente (créées, ou
+     * libérées par un membre) : il les reçoit après la validation de la
+     * mutation. La fonction rendue désabonne.
+     */
+    onPendingRequest(listener) {
+        this.pendingRequestListeners.add(listener);
+        return () => this.pendingRequestListeners.delete(listener);
+    }
     /**
      * Point unique d'écriture. `fn` reçoit une `Mutation` et s'exécute dans une
      * transaction exclusive ; à sa sortie, les invariants sont vérifiés sur l'état
@@ -777,6 +790,7 @@ export class Store {
         if (this.activeMutation)
             throw new Error("Store.mutate is not reentrant: use the Mutation passed to the running mutation.");
         let emails = [];
+        let pending = [];
         const run = this.db.transaction(() => {
             const tx = new Mutation(this, actor);
             this.activeMutation = tx;
@@ -784,6 +798,7 @@ export class Store {
                 const result = fn(tx);
                 tx.finish();
                 emails = tx.emailNotificationIds;
+                pending = tx.pendingRequestIds;
                 return result;
             }
             finally {
@@ -793,6 +808,13 @@ export class Store {
         const result = run.immediate();
         if (emails.length > 0 && this.emailListener)
             this.emailListener(emails);
+        if (pending.length > 0 && this.pendingRequestListeners.size > 0) {
+            for (const id of pending) {
+                const request = this.getAgentRequest(id);
+                for (const listener of [...this.pendingRequestListeners])
+                    listener(request);
+            }
+        }
         return result;
     }
 }
@@ -809,6 +831,8 @@ export class Mutation {
     touched = new Map();
     /** Notifications créées par la mutation dont le destinataire veut un e-mail. */
     emailNotificationIds = [];
+    /** Demandes passées en attente par la mutation : créées, ou libérées. */
+    pendingRequestIds = [];
     /** Demande pour laquelle agit l'agent, lue au début de la mutation. */
     request;
     /** Jeton avec lequel agit l'agent. */
@@ -1690,6 +1714,7 @@ export class Mutation {
          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
             .run(request.id, request.authorId, request.targetSpaceId, request.kind, request.contextTaskId, request.contextIdeaId, request.text, request.status, request.createdAt, request.updatedAt);
         this.createdRequestIds.add(request.id);
+        this.pendingRequestIds.push(request.id);
         this.touchRequest(request);
         return request;
     }
@@ -1735,6 +1760,7 @@ export class Mutation {
             throw new InvariantError(`Request ${id} is ${current.status}: only a processing request can be released.`);
         this.db.prepare("UPDATE agent_requests SET status = 'pending', claimed_at = NULL, claimed_by_token_id = NULL, updated_at = ? WHERE id = ?").run(this.now, id);
         const released = this.store.getAgentRequest(id);
+        this.pendingRequestIds.push(id);
         this.touchRequest(released);
         return released;
     }

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

@@ -0,0 +1,30 @@
+/**
+ * Présence des veilleurs de notifications, par jeton d'agent.
+ *
+ * Un veilleur enchaîne des attentes longues sur `GET /api/agent/requests/wait`.
+ * Le registre rend sa présence observable : `enable_notifications` répond
+ * « déjà armé », la page Agent de la GUI affiche « à l'écoute ».
+ *
+ * État de connexion, donc volatile : il vit en mémoire du processus du site et
+ * disparaît avec lui.
+ */
+/**
+ * Délai de grâce entre deux attentes d'un même veilleur : le jeton reste
+ * « à l'écoute » pendant le court intervalle où aucune attente n'est ouverte.
+ */
+export declare const WATCHER_GRACE_MS: number;
+export interface WatcherStatus {
+    armed: boolean;
+    /** Début de la série d'attentes en cours, null sans veilleur. */
+    since: string | null;
+    /** Dernière activité connue d'un veilleur de ce jeton, null si aucune. */
+    lastSeen: string | null;
+}
+export declare class WatcherRegistry {
+    private readonly now;
+    private readonly presence;
+    constructor(now?: () => number);
+    /** Déclare une attente de veilleur du jeton `tokenId`. La fonction rendue la clôt ; elle doit toujours être appelée. */
+    begin(tokenId: string): () => void;
+    status(tokenId: string): WatcherStatus;
+}

package/dist/src/core/watchers.js

@@ -0,0 +1,50 @@
+/**
+ * Présence des veilleurs de notifications, par jeton d'agent.
+ *
+ * Un veilleur enchaîne des attentes longues sur `GET /api/agent/requests/wait`.
+ * Le registre rend sa présence observable : `enable_notifications` répond
+ * « déjà armé », la page Agent de la GUI affiche « à l'écoute ».
+ *
+ * État de connexion, donc volatile : il vit en mémoire du processus du site et
+ * disparaît avec lui.
+ */
+/**
+ * Délai de grâce entre deux attentes d'un même veilleur : le jeton reste
+ * « à l'écoute » pendant le court intervalle où aucune attente n'est ouverte.
+ */
+export const WATCHER_GRACE_MS = 2 * 60 * 1000;
+export class WatcherRegistry {
+    now;
+    presence = new Map();
+    constructor(now = Date.now) {
+        this.now = now;
+    }
+    /** Déclare une attente de veilleur du jeton `tokenId`. La fonction rendue la clôt ; elle doit toujours être appelée. */
+    begin(tokenId) {
+        const now = this.now();
+        const current = this.presence.get(tokenId);
+        const continuing = current !== undefined && (current.inflight > 0 || now - current.lastSeen <= WATCHER_GRACE_MS);
+        this.presence.set(tokenId, continuing ? { ...current, inflight: current.inflight + 1, lastSeen: now } : { inflight: 1, since: now, lastSeen: now });
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            const active = this.presence.get(tokenId);
+            if (!active)
+                return;
+            this.presence.set(tokenId, { ...active, inflight: Math.max(0, active.inflight - 1), lastSeen: this.now() });
+        };
+    }
+    status(tokenId) {
+        const entry = this.presence.get(tokenId);
+        if (!entry)
+            return { armed: false, since: null, lastSeen: null };
+        const armed = entry.inflight > 0 || this.now() - entry.lastSeen <= WATCHER_GRACE_MS;
+        if (!armed) {
+            this.presence.delete(tokenId);
+            return { armed: false, since: null, lastSeen: new Date(entry.lastSeen).toISOString() };
+        }
+        return { armed: true, since: new Date(entry.since).toISOString(), lastSeen: new Date(entry.lastSeen).toISOString() };
+    }
+}

package/dist/src/index.js

@@ -19,6 +19,10 @@ Usage :
                                     (dossier <fichier>.attachments).
   mcp-organizer --claude-setup-mcp [--force] --url=<URL du site> --token=<jeton>
                                     Écrit l'entrée du mode MCP dans ./.mcp.json.
+  mcp-organizer --watch <id du jeton>
+                                    Veilleur de notifications : une ligne par demande passée en attente.
+                                    Lancé par l'outil Monitor de l'agent, avec la commande que rend
+                                    l'outil enable_notifications.
   mcp-organizer --version           Affiche la version.
   mcp-organizer --help              Affiche cette aide.
 
@@ -50,6 +54,12 @@ async function main() {
         const { runSetupMcp } = await import("./cli/setup-mcp.js");
         process.exit(runSetupMcp(argv, process.cwd()));
     }
+    // Le veilleur lit l'URL du site et le jeton dans le relais déposé par enable_notifications.
+    const watchIndex = argv.indexOf("--watch");
+    if (watchIndex !== -1) {
+        const { runWatchMode } = await import("./cli/watch.js");
+        process.exit(await runWatchMode(argv[watchIndex + 1]));
+    }
     const rootDir = findProjectRoot(path.dirname(fileURLToPath(import.meta.url)));
     const siteCommand = SITE_COMMANDS.some((flag) => argv.includes(flag));
     // Les commandes du site ouvrent la base : better-sqlite3 doit avoir son module natif.