@stratta/mcp 0.13.1 → 0.14.0

package/README.md

@@ -34,7 +34,7 @@ https://stratta.ch/mcp
 That is the shorter path, the one the dashboard walks you through for Claude,
 ChatGPT, Claude Code, Codex, Cursor, VS Code, Gemini CLI and Windsurf, and the
 only one that works in an agent running in the cloud (claude.ai, ChatGPT). It
-serves 35 of the 36 tools below, **ingestion included**: the pre-pass script is
+serves 54 of the 55 tools below, **ingestion included**: the pre-pass script is
 downloaded from https://stratta.ch/ingest-prepass.py when it is not on disk.
 See https://stratta.ch/docs/en/guides/connect-remote.
 
@@ -176,8 +176,8 @@ named `E2E dossier <timestamp>` and does not delete it.
 
 ## Tools exposed
 
-36 tools, generated from one catalogue shared with the remote connector (which
-serves the same 33 minus `add_attachment`).
+55 tools, generated from one catalogue shared with the remote connector (which
+serves the same 54, everything minus `add_attachment`).
 
 **Read** (10 tools — query the norms of your workspace):
 
@@ -194,31 +194,50 @@ serves the same 33 minus `add_attachment`).
 | `get_figure`      | Retrieve a figure inline (base64 ImageContent).                                         |
 | `get_cross_refs`  | Outgoing cross-refs from a section to other norms.                                      |
 
-**Site** (3 tools — what public Swiss registers know about a plot):
-
-| Tool               | Purpose                                                                                                                             |
-| ------------------ | ----------------------------------------------------------------------------------------------------------------------------------- |
-| `scan_site`        | Collect municipality, parcel, elevation, geology, nearby boreholes, polluted sites, hazards and noise class around a Swiss address. |
-| `get_site_context` | Read what the scan settled, and — separately — what it could not, with the reason.                                                  |
-| `get_boreholes`    | Read the boreholes nearest the site with their logged strata, SIA 261 ground class, water table, and links to cantonal documents.   |
-
-**Dossier** (13 tools — keep what was decided on a project):
-
-| Tool                | Purpose                                                                                                |
-| ------------------- | ------------------------------------------------------------------------------------------------------ |
-| `list_dossiers`     | Your organisation's dossiers, most recently touched first, with open-question counts.                  |
-| `open_dossier`      | Open a project's dossier, creating it if needed. Idempotent on the name.                               |
-| `open_question`     | Open one question to settle, with optional named options. Idempotent on the title.                     |
-| `save_finding`      | Record one piece of evidence: a cited article, a retained value and why, an observation.               |
-| `record_decision`   | Settle a question with a decision the engineer has confirmed, and the retained option.                 |
-| `load_dossier`      | Reload everything: questions with their evidence and decisions, open ones first.                       |
-| `resolve_question`  | Close a question without a decision, or reopen one. The evidence stays.                                |
-| `list_attachments`  | The project attachments of a dossier: site reports, borehole logs, minutes, data sheets.               |
-| `read_attachment`   | Read an attachment's text as Markdown, page by page.                                                   |
-| `search_in_dossier` | Full-text search over a dossier's attachments, with the page of each hit.                              |
-| `add_attachment`    | Upload a file from the user's machine to a dossier (PDF, DOCX, XLSX, images, text). Local server only. |
-| `list_templates`    | The checklists the organisation wrote for its types of structure.                                      |
-| `apply_template`    | Open a template's questions in a dossier and file the clauses that resolve in the corpus.              |
+**Site** (10 tools — what public Swiss registers know about a plot, and the site sheet as the app shows it):
+
+| Tool                       | Purpose                                                                                                                             |
+| -------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
+| `scan_site`                | Collect municipality, parcel, elevation, geology, nearby boreholes, polluted sites, hazards and noise class around a Swiss address. |
+| `get_site_context`         | Read what the scan settled, and — separately — what it could not, with the reason.                                                  |
+| `get_boreholes`            | Read the boreholes nearest the site with their logged strata, SIA 261 ground class, water table, and links to cantonal documents.   |
+| `list_sites`               | The site sheets of the organisation, with their dossier, canton and scan status.                                                    |
+| `get_site`                 | The sheet as the app shows it: every fact with its key, status, source, notice and attribution, and the scan with its sources.      |
+| `get_site_section`         | The section along the axis: terrain, modelled bedrock, geology bands and the boreholes of the corridor with their logs.             |
+| `list_site_overlays`       | The map areas around the point (polluted sites, hazards, water protection), with distance and coverage of the site point.           |
+| `get_groundwater_contours` | The cantonal piezometric contours stored by the scan, with the aquifer name and elevation.                                          |
+| `list_site_photos`         | The photos uploaded on the sheet, with position, direction, instant and note. No image, no link.                                    |
+| `list_site_neighbours`     | The organisation's other sheets within a radius, with the distance and the geological unit their scan established.                  |
+
+**Dossier** (25 tools — keep what was decided on a project, and everything the dossier page can do to a question):
+
+| Tool                   | Purpose                                                                                                |
+| ---------------------- | ------------------------------------------------------------------------------------------------------ |
+| `list_dossiers`        | Your organisation's dossiers, most recently touched first, with open-question counts and site id.      |
+| `open_dossier`         | Open a project's dossier, creating it if needed. Idempotent on the name.                               |
+| `open_question`        | Open one question to settle, with optional named options. Idempotent on the title.                     |
+| `save_finding`         | Record one piece of evidence: a cited article, a retained value and why, an observation.               |
+| `record_decision`      | Settle a question with a decision the engineer has confirmed, and the retained option.                 |
+| `load_dossier`         | Reload everything: questions with their evidence and decisions, open ones first.                       |
+| `resolve_question`     | Close a question without a decision, or reopen one. The evidence stays.                                |
+| `list_attachments`     | The project attachments of a dossier: site reports, borehole logs, minutes, data sheets.               |
+| `read_attachment`      | Read an attachment's text as Markdown, page by page.                                                   |
+| `search_in_dossier`    | Full-text search over a dossier's attachments, with the page of each hit.                              |
+| `add_attachment`       | Upload a file from the user's machine to a dossier (PDF, DOCX, XLSX, images, text). Local server only. |
+| `list_templates`       | The checklists the organisation wrote for its types of structure.                                      |
+| `apply_template`       | Open a template's questions in a dossier and file the clauses that resolve in the corpus.              |
+| `list_questions`       | The questions of a dossier, paginated, with status, assignee, due date, options and decision title.    |
+| `get_question`         | One question in full: options, decision, evidence with every citation field, comments with authors.    |
+| `get_dossier_activity` | The history of a dossier, most recent first, paginated: who did what, from the app or an agent.        |
+| `list_exports`         | The verification notes and journals exported from a dossier, with hash and trusted timestamp.          |
+| `update_question`      | Reword a question, assign it by e-mail address, set or clear its due date.                             |
+| `add_option`           | Add one way of settling a question. Idempotent on the name.                                            |
+| `update_option`        | Rename or describe an option, or mark it retained (the others are released).                           |
+| `delete_option`        | Remove an option; its evidence stays on the question. Asks the user first.                             |
+| `delete_question`      | Delete a question opened by mistake; its evidence stays, unfiled. Asks the user first.                 |
+| `add_comment`          | Leave a signed remark on a dossier, a question or an entry.                                            |
+| `update_entry`         | Correct an entry's wording, value, confidence or citation in place.                                    |
+| `attach_entry`         | File an entry under a question and optionally an option, or unfile it.                                 |
 
 A dossier is read, annotated, reviewed and exported from
 [stratta.ch/dossiers](https://stratta.ch/dossiers).

package/dist/confirm.d.ts

@@ -9,7 +9,16 @@ import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
  * `confirmed: true` when it does not. The Convex function never sees the
  * difference.
  */
-export declare const CONFIRMED_TOOLS: Record<string, (args: Record<string, unknown>) => string>;
+type Confirmation = {
+    /** What is at stake, as the dialog names it. */
+    what: string;
+    /** The one line the user reads, built from the arguments. */
+    summary: (args: Record<string, unknown>) => string;
+    /** The question asked. A removal never asks "Record it". */
+    prompt: string;
+};
+export declare const CONFIRMED_TOOLS: Record<string, Confirmation>;
 export declare const CONFIRMATION_HINT: string;
 /** `null` when the call may proceed, a tool result to return otherwise. */
 export declare function confirmWithUser(server: Pick<Server, 'getClientCapabilities' | 'elicitInput'>, toolName: string, args: Record<string, unknown>): Promise<CallToolResult | null>;
+export {};

package/dist/confirm.js

@@ -1,32 +1,45 @@
-/**
- * The confirmation step before a decision is written, on stdio.
- *
- * Same contract as the remote gate: `confirmed: true` in the arguments means
- * the agent already asked the user; otherwise the client is asked through an
- * elicitation when it supports one, and told to come back with
- * `confirmed: true` when it does not. The Convex function never sees the
- * difference.
- */
+const decisionSummary = (args) => [
+    args.title,
+    args.value ? `= ${String(args.value)}` : null,
+    args.retainedOption ? `(option ${String(args.retainedOption)})` : null,
+]
+    .filter(Boolean)
+    .map(String)
+    .join(' ');
 export const CONFIRMED_TOOLS = {
-    record_decision: (args) => [
-        args.title,
-        args.value ? `= ${String(args.value)}` : null,
-        args.retainedOption ? `(option ${String(args.retainedOption)})` : null,
-    ]
-        .filter(Boolean)
-        .map(String)
-        .join(' '),
-    resolve_question: (args) => args.resolved === false
-        ? 'reopen this question'
-        : 'close this question without a decision',
+    record_decision: {
+        what: 'Decision',
+        summary: decisionSummary,
+        prompt: 'Record it in the dossier?',
+    },
+    resolve_question: {
+        what: 'Question',
+        summary: (args) => args.resolved === false
+            ? 'reopen this question'
+            : 'close this question without a decision',
+        prompt: 'Record it in the dossier?',
+    },
+    // The two deletions of 0.14.0. The gate only sees ids, so the line says
+    // what goes and what stays rather than naming the row.
+    delete_question: {
+        what: 'Question',
+        summary: () => 'delete this question with its options, its comments and its decision; ' +
+            'its evidence stays in the dossier, unfiled',
+        prompt: 'Delete it?',
+    },
+    delete_option: {
+        what: 'Option',
+        summary: () => 'remove this option; the evidence filed under it stays on the question',
+        prompt: 'Remove it?',
+    },
 };
 export const CONFIRMATION_HINT = 'Not recorded: this client cannot ask the user directly. Confirm the ' +
     'decision with the user in the conversation, then call again with ' +
     'confirmed: true.';
 /** `null` when the call may proceed, a tool result to return otherwise. */
 export async function confirmWithUser(server, toolName, args) {
-    const summary = CONFIRMED_TOOLS[toolName];
-    if (!summary || args.confirmed === true)
+    const confirmation = CONFIRMED_TOOLS[toolName];
+    if (!confirmation || args.confirmed === true)
         return null;
     if (!server.getClientCapabilities()?.elicitation) {
         return {
@@ -37,10 +50,10 @@ export async function confirmWithUser(server, toolName, args) {
     }
     const result = await server.elicitInput({
         mode: 'form',
-        message: `${toolName === 'record_decision' ? 'Decision' : 'Question'}: ${summary(args)}\n\nRecord it in the dossier?`,
+        message: `${confirmation.what}: ${confirmation.summary(args)}\n\n${confirmation.prompt}`,
         requestedSchema: {
             type: 'object',
-            properties: { confirm: { type: 'boolean', title: 'Record it' } },
+            properties: { confirm: { type: 'boolean', title: 'Confirm' } },
             required: ['confirm'],
         },
     });

package/dist/errors.js

@@ -47,6 +47,7 @@ const HELP = {
     RATE_LIMITED: `${DOCS}/resources/troubleshooting`,
     DOSSIER_NOT_FOUND: `${DOCS}/mcp/dossier-tools`,
     DOSSIER_CLOSED: `${DOCS}/guides/suivre-un-projet`,
+    READ_ONLY: `${DOCS}/account/plans`,
     ENTRY_NOT_FOUND: `${DOCS}/mcp/dossier-tools`,
     TOO_MANY_DOSSIERS: `${DOCS}/mcp/dossier-tools`,
     TOO_MANY_ENTRIES: `${DOCS}/mcp/dossier-tools`,
@@ -129,6 +130,45 @@ export function formatToolError(err) {
                         "Cette entrée n'existe pas, ou elle appartient à un autre dossier.",
                         'Rechargez le dossier avec `load_dossier` pour obtenir des identifiants à jour.',
                     ]);
+                case 'QUESTION_NOT_FOUND':
+                    return withHelp(data, [
+                        "Cette question n'existe pas dans votre organisation, ou elle appartient à un autre dossier.",
+                        'Appelez `list_questions` sur le dossier pour obtenir des identifiants à jour.',
+                    ]);
+                case 'OPTION_NOT_FOUND':
+                    return withHelp(data, [
+                        "Cette option n'existe pas, ou elle appartient à une autre question.",
+                        'Appelez `get_question` pour lire les options et leurs identifiants.',
+                    ]);
+                case 'OPTION_WITHOUT_QUESTION':
+                    return withHelp(data, [
+                        'Une option se rattache à une question : donnez `questionId` avec `optionId`.',
+                    ]);
+                case 'DECISION_IS_BOUND':
+                    return withHelp(data, [
+                        'Une décision appartient à sa question et ne se déplace pas. Corrigez-la avec `update_entry`, ou rouvrez la question avec `resolve_question` (resolved: false).',
+                    ]);
+                case 'NOT_A_MEMBER':
+                    return withHelp(data, [
+                        "Cette adresse ne correspond à aucun membre de l'organisation. Demandez à l'utilisateur l'adresse exacte, ou laissez la question sans responsable.",
+                    ]);
+                case 'INVALID_DATE':
+                    return withHelp(data, [
+                        'La date attendue est un jour ISO, par exemple « 2026-10-15 ».',
+                    ]);
+                case 'SITE_NOT_FOUND':
+                    return withHelp(data, [
+                        "Cette fiche de site n'existe pas dans votre organisation.",
+                        'Appelez `list_sites`, ou lisez `siteId` sur la ligne du dossier dans `list_dossiers`.',
+                    ]);
+                case 'TOO_MANY_QUESTIONS':
+                    return withHelp(data, [
+                        'Ce dossier a atteint son plafond de questions. Ne réessayez pas ; closez ou supprimez celles qui ne comptent plus.',
+                    ]);
+                case 'TOO_MANY_OPTIONS':
+                    return withHelp(data, [
+                        'Cette question a déjà dix options, le maximum. Ne réessayez pas ; retirez-en une avec `delete_option` si une nouvelle est nécessaire.',
+                    ]);
                 case 'TOO_MANY_DOSSIERS':
                     return withHelp(data, [
                         'Cette organisation a atteint son plafond de dossiers.',

package/dist/tools/catalog.gen.js

@@ -252,6 +252,136 @@ export const CATALOG = [
             "siteId": "Site id returned by scan_site."
         }
     },
+    {
+        "name": "list_sites",
+        "title": "Site sheets",
+        "description": "List the site sheets of the organization, most recently touched first, each with the dossier it belongs to, the municipality and canton, the search radius and the status of its current scan. Call it when the user names a site or an address rather than a dossier, or to find the siteId of a sheet opened from the app; a dossier row from list_dossiers also carries its siteId.",
+        "annotations": {
+            "readOnlyHint": true,
+            "destructiveHint": false,
+            "idempotentHint": true,
+            "openWorldHint": false
+        },
+        "transports": [
+            "stdio",
+            "remote"
+        ],
+        "params": {
+            "limit": "How many sites to return, 1 to 200. Default 50; truncated says when more exist."
+        }
+    },
+    {
+        "name": "get_site",
+        "title": "Read a site sheet",
+        "description": "Read a site sheet as the app shows it: every fact with its stable key, its status (established, indicative, absent, uncovered), its source with the date the data was current, the official notice and attribution when the source carries one, and the scan with each source and whether it answered. get_site_context is the summary shaped for an answer; call this when you need to quote a source line, cite a fact key in save_finding, or tell the user which source failed. Facts are registers, never a geotechnical study.",
+        "annotations": {
+            "readOnlyHint": true,
+            "destructiveHint": false,
+            "idempotentHint": true,
+            "openWorldHint": false
+        },
+        "transports": [
+            "stdio",
+            "remote"
+        ],
+        "params": {
+            "siteId": "Site id from scan_site, list_sites or a dossier row."
+        }
+    },
+    {
+        "name": "get_site_section",
+        "title": "Read the section",
+        "description": "Read the geological section drawn on a site sheet: the axis from A to B, the corridor width, the measured terrain line, the modelled bedrock top, the geology bands sampled along the axis, and the boreholes inside the corridor with their logged strata, projected on the axis. Call it when the question is about what lies along a line rather than at a point. Without an axis drawn in the app, it says so and returns no lines. Nothing is interpolated between boreholes.",
+        "annotations": {
+            "readOnlyHint": true,
+            "destructiveHint": false,
+            "idempotentHint": true,
+            "openWorldHint": false
+        },
+        "transports": [
+            "stdio",
+            "remote"
+        ],
+        "params": {
+            "siteId": "Site id from scan_site, list_sites or a dossier row.",
+            "maxPoints": "How many points of the terrain and bedrock lines to return, evenly spaced, 2 to 200. Default 60."
+        }
+    },
+    {
+        "name": "list_site_overlays",
+        "title": "Map areas around a site",
+        "description": "List the areas the site map draws around the point: polluted sites, natural hazard zones and water protection sectors read from the canton, each with whether it covers the site point or how many metres away it stops, its area and its layer. Coordinates are left out unless asked for. Call it after get_site_context when a constraint is near and the user asks how near; the sheet answers at the point, this answers in the radius.",
+        "annotations": {
+            "readOnlyHint": true,
+            "destructiveHint": false,
+            "idempotentHint": true,
+            "openWorldHint": false
+        },
+        "transports": [
+            "stdio",
+            "remote"
+        ],
+        "params": {
+            "siteId": "Site id from scan_site, list_sites or a dossier row.",
+            "includeGeometry": "Return the polygon rings in LV95 as well. Default false: rings run to hundreds of points."
+        }
+    },
+    {
+        "name": "get_groundwater_contours",
+        "title": "Piezometric contours",
+        "description": "Read the cantonal piezometric contours the scan stored around a site: for each contour the aquifer name, the water table elevation in metres above sea level and the source layer. Cantons that publish none return an empty list and say whether the reading happened. A contour is the canton's interpretation of an aquifer, not a measurement at the site: prefer a water table logged in a nearby borehole (get_boreholes) when one exists, and quote a contour with its name.",
+        "annotations": {
+            "readOnlyHint": true,
+            "destructiveHint": false,
+            "idempotentHint": true,
+            "openWorldHint": false
+        },
+        "transports": [
+            "stdio",
+            "remote"
+        ],
+        "params": {
+            "siteId": "Site id from scan_site, list_sites or a dossier row.",
+            "includeGeometry": "Return the contour vertices in LV95 as well. Default false."
+        }
+    },
+    {
+        "name": "list_site_photos",
+        "title": "Site photos",
+        "description": "List the photos the engineer uploaded on a site sheet: name, position in LV95 when the photo carries one (from its EXIF data or placed by hand), shooting direction, the instant the camera recorded, and the note written on it. No image is returned and no link: the photo is looked at in the app. Call it to know what was observed on site and when, before writing an observation.",
+        "annotations": {
+            "readOnlyHint": true,
+            "destructiveHint": false,
+            "idempotentHint": true,
+            "openWorldHint": false
+        },
+        "transports": [
+            "stdio",
+            "remote"
+        ],
+        "params": {
+            "siteId": "Site id from scan_site, list_sites or a dossier row."
+        }
+    },
+    {
+        "name": "list_site_neighbours",
+        "title": "Neighbouring projects",
+        "description": "List the other site sheets of the organization within a radius of this one, nearest first, with the distance, the geological unit their own scan established and whether it is the same as here, and the dossier that carries them with its counts of open and decided questions. This is what the public registers cannot say: the office already worked three hundred metres away. Nothing is interpolated: these are links to dossiers to reload, not values.",
+        "annotations": {
+            "readOnlyHint": true,
+            "destructiveHint": false,
+            "idempotentHint": true,
+            "openWorldHint": false
+        },
+        "transports": [
+            "stdio",
+            "remote"
+        ],
+        "params": {
+            "siteId": "Site id from scan_site, list_sites or a dossier row.",
+            "radius": "How far to look, in metres, 50 to 5000. Default 500. At most twelve neighbours are returned."
+        }
+    },
     {
         "name": "list_dossiers",
         "title": "Project dossiers",
@@ -517,6 +647,253 @@ export const CATALOG = [
             "templateId": "The template, from list_templates."
         }
     },
+    {
+        "name": "list_questions",
+        "title": "Questions of a dossier",
+        "description": "List the questions of one dossier, one page at a time, with what the dossier page shows and load_dossier leaves out: status, assignee, due date, author, dates, the options with their ids and the title of the decision when there is one. Filter by status to read only what is still open. Use load_dossier to resume a project; use this to work through the questions one by one, then get_question on the one that matters. When nextCursor is present, call again with it as cursor.",
+        "annotations": {
+            "readOnlyHint": true,
+            "destructiveHint": false,
+            "idempotentHint": true,
+            "openWorldHint": false
+        },
+        "transports": [
+            "stdio",
+            "remote"
+        ],
+        "params": {
+            "dossierId": "Dossier id from list_dossiers, open_dossier or load_dossier.",
+            "status": "open, decided or closed. Omit for all.",
+            "limit": "Questions per page, 1 to 200. Default 50.",
+            "cursor": "The nextCursor of the previous page."
+        }
+    },
+    {
+        "name": "get_question",
+        "title": "Read a question",
+        "description": "Read one question in full: its wording, status, assignee and due date, its options with their ids and descriptions, its decision, its evidence with every citation field (norm, section path, page, edition, attachment and page) and the option each piece argues for, and the comments left on the question and on those entries, each with its author. Evidence comes one page at a time; when nextCursor is present, call again with it as cursor. Call it before adding to a question, so nothing already filed is filed twice.",
+        "annotations": {
+            "readOnlyHint": true,
+            "destructiveHint": false,
+            "idempotentHint": true,
+            "openWorldHint": false
+        },
+        "transports": [
+            "stdio",
+            "remote"
+        ],
+        "params": {
+            "questionId": "Question id from list_questions, load_dossier or open_question.",
+            "limit": "Evidence entries per page, 1 to 200. Default 50.",
+            "cursor": "The nextCursor of the previous page."
+        }
+    },
+    {
+        "name": "get_dossier_activity",
+        "title": "Dossier history",
+        "description": "Read the history of a dossier, most recent first: who did what and when, from the app or from an agent, each line with the question or the entry it concerns. Call it when the user asks what changed since they last looked, or who took a decision. One page at a time; when nextCursor is present, call again with it as cursor. Lines are written in French at the time of the act, as the app shows them.",
+        "annotations": {
+            "readOnlyHint": true,
+            "destructiveHint": false,
+            "idempotentHint": true,
+            "openWorldHint": false
+        },
+        "transports": [
+            "stdio",
+            "remote"
+        ],
+        "params": {
+            "dossierId": "Dossier id from list_dossiers, open_dossier or load_dossier.",
+            "limit": "Lines per page, 1 to 200. Default 50.",
+            "cursor": "The nextCursor of the previous page."
+        }
+    },
+    {
+        "name": "list_exports",
+        "title": "Dossier exports",
+        "description": "List the verification notes and journals exported from a dossier, most recent first, each with its kind, its SHA-256 hash, its size, the trusted timestamp when one was obtained, the methodology version in force and who exported it. The file itself is downloaded from the dossier page; this tells the user whether a note exists and lets them check a hash they were sent.",
+        "annotations": {
+            "readOnlyHint": true,
+            "destructiveHint": false,
+            "idempotentHint": true,
+            "openWorldHint": false
+        },
+        "transports": [
+            "stdio",
+            "remote"
+        ],
+        "params": {
+            "dossierId": "Dossier id from list_dossiers, open_dossier or load_dossier."
+        }
+    },
+    {
+        "name": "update_question",
+        "title": "Edit a question",
+        "description": "Reword a question, rewrite what is at stake, assign it to a member of the organization by e-mail address, or set its due date. Pass only the fields to change; pass null to clear the assignee or the due date. Status changes go through record_decision and resolve_question, not here. Only when the user asked for the change.",
+        "annotations": {
+            "readOnlyHint": false,
+            "destructiveHint": false,
+            "idempotentHint": true,
+            "openWorldHint": false
+        },
+        "transports": [
+            "stdio",
+            "remote"
+        ],
+        "params": {
+            "questionId": "Question id from list_questions, load_dossier or open_question.",
+            "title": "The new wording, in one line, phrased as a question.",
+            "body": "What is at stake and why it is not settled, in two or three sentences.",
+            "assigneeEmail": "E-mail address of the member to assign the question to. null removes the assignee.",
+            "dueAt": "Due date as an ISO day, e.g. \"2026-10-15\". null removes it."
+        }
+    },
+    {
+        "name": "add_option",
+        "title": "Add an option",
+        "description": "Add one way of settling a question, when a new variant comes up after the question was opened: \"keep the pile and test it\", \"redistribute on P37 and P39\". Idempotent on the name: the same words return the option already listed. Ten options per question at most. Returns optionId and created; the option is retained later by record_decision or update_option.",
+        "annotations": {
+            "readOnlyHint": false,
+            "destructiveHint": false,
+            "idempotentHint": true,
+            "openWorldHint": false
+        },
+        "transports": [
+            "stdio",
+            "remote"
+        ],
+        "params": {
+            "questionId": "Question id from list_questions, load_dossier or open_question.",
+            "name": "The option in a few words, as it will be listed.",
+            "description": "What the option implies, in one or two sentences, when the name is not enough."
+        }
+    },
+    {
+        "name": "update_option",
+        "title": "Edit an option",
+        "description": "Rename or describe an option of a question, or mark it as the one retained. Retaining one option releases the others: a choice has one answer. Retaining here does not settle the question; call record_decision for that, which names the retained option itself. Pass only the fields to change. Only when the user asked for it.",
+        "annotations": {
+            "readOnlyHint": false,
+            "destructiveHint": false,
+            "idempotentHint": true,
+            "openWorldHint": false
+        },
+        "transports": [
+            "stdio",
+            "remote"
+        ],
+        "params": {
+            "optionId": "Option id from get_question, list_questions or load_dossier.",
+            "name": "The new name of the option.",
+            "description": "The new description.",
+            "retained": "true to mark this option as retained (the others are released), false to release it."
+        }
+    },
+    {
+        "name": "delete_option",
+        "title": "Remove an option",
+        "description": "Remove an option from a question. The evidence filed under it stays on the question, unfiled from the option. Irreversible: the user is asked to confirm through the client before anything is removed, unless confirmed is true because they already did in the conversation. Only when the user asked for it.",
+        "annotations": {
+            "readOnlyHint": false,
+            "destructiveHint": true,
+            "idempotentHint": false,
+            "openWorldHint": false
+        },
+        "transports": [
+            "stdio",
+            "remote"
+        ],
+        "params": {
+            "optionId": "Option id from get_question, list_questions or load_dossier.",
+            "confirmed": "true when the user already confirmed the removal in the conversation. Otherwise the user is asked through the client first."
+        }
+    },
+    {
+        "name": "delete_question",
+        "title": "Delete a question",
+        "description": "Delete a question from a dossier. Its evidence stays in the dossier, unfiled; its options, its comments and its decision entry go with it. Irreversible: the user is asked to confirm through the client before anything is deleted, unless confirmed is true because they already did in the conversation. A question that stopped mattering is closed with resolve_question, not deleted; delete only a question opened by mistake, and only when the user says so.",
+        "annotations": {
+            "readOnlyHint": false,
+            "destructiveHint": true,
+            "idempotentHint": false,
+            "openWorldHint": false
+        },
+        "transports": [
+            "stdio",
+            "remote"
+        ],
+        "params": {
+            "questionId": "Question id from list_questions, load_dossier or open_question.",
+            "confirmed": "true when the user already confirmed the deletion in the conversation. Otherwise the user is asked through the client first."
+        }
+    },
+    {
+        "name": "add_comment",
+        "title": "Leave a comment",
+        "description": "Leave a remark on a dossier, on one of its questions or on one entry: a doubt about a value, a note for a colleague, the reason a piece of evidence was set aside. A comment is signed by the connected user and is not evidence: what the norm says goes through save_finding. A signed-off dossier still takes comments. Write it in the user's own words, only when they asked to leave one.",
+        "annotations": {
+            "readOnlyHint": false,
+            "destructiveHint": false,
+            "idempotentHint": false,
+            "openWorldHint": false
+        },
+        "transports": [
+            "stdio",
+            "remote"
+        ],
+        "params": {
+            "dossierId": "Dossier id from list_dossiers, open_dossier or load_dossier.",
+            "body": "The comment, one to a few sentences.",
+            "questionId": "The question the comment is about, when it is about one.",
+            "entryId": "The entry the comment is about, when it is about one."
+        }
+    },
+    {
+        "name": "update_entry",
+        "title": "Correct an entry",
+        "description": "Correct a piece of evidence or a decision in place: its wording, its value, its confidence, or the citation (norm, section path, page, edition) when the wrong clause was cited. Pass only the fields to change; pass page null to clear it. The kind and the question do not change here (attach_entry moves an entry). Only when the user asked for the correction; never rewrite what a colleague wrote without saying so.",
+        "annotations": {
+            "readOnlyHint": false,
+            "destructiveHint": false,
+            "idempotentHint": true,
+            "openWorldHint": false
+        },
+        "transports": [
+            "stdio",
+            "remote"
+        ],
+        "params": {
+            "entryId": "Entry id from get_question or load_dossier.",
+            "title": "The fact in one line, as an engineer would write it in a report.",
+            "detail": "The reasoning in one or two sentences.",
+            "value": "The retained value with its unit, e.g. \"30 deg\".",
+            "confidence": "established, judgement or to_confirm.",
+            "normCode": "Norm the entry comes from, e.g. \"SIA 267\".",
+            "sectionPath": "Exact section path, e.g. \"9.5.2.1\".",
+            "page": "Page in the norm. null clears it.",
+            "normEdition": "The edition cited, e.g. \"2013\"."
+        }
+    },
+    {
+        "name": "attach_entry",
+        "title": "File an entry under a question",
+        "description": "File a piece of evidence under a question, and optionally under one of its options, or take it out with questionId null. This is how the unclassified evidence of load_dossier gets sorted: read it, find the question it answers, file it. A decision cannot be moved: it belongs to its question. Filing where it already is changes nothing.",
+        "annotations": {
+            "readOnlyHint": false,
+            "destructiveHint": false,
+            "idempotentHint": true,
+            "openWorldHint": false
+        },
+        "transports": [
+            "stdio",
+            "remote"
+        ],
+        "params": {
+            "entryId": "Entry id from get_question or load_dossier.",
+            "questionId": "The question to file the entry under, or null to leave it unfiled.",
+            "optionId": "The option of that question the entry argues for, or null for none."
+        }
+    },
     {
         "name": "ingest_status",
         "title": "Check ingestion status",

package/dist/tools/dossier.d.ts

@@ -82,6 +82,81 @@ export declare const applyTemplate: import("./define.js").ToolDef<{
     dossierId: z.ZodString;
     templateId: z.ZodString;
 }>;
+export declare const listQuestions: import("./define.js").ToolDef<{
+    dossierId: z.ZodString;
+    status: z.ZodOptional<z.ZodEnum<{
+        open: "open";
+        decided: "decided";
+        closed: "closed";
+    }>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+}>;
+export declare const getQuestion: import("./define.js").ToolDef<{
+    questionId: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+}>;
+export declare const getDossierActivity: import("./define.js").ToolDef<{
+    dossierId: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+}>;
+export declare const listExports: import("./define.js").ToolDef<{
+    dossierId: z.ZodString;
+}>;
+export declare const updateQuestion: import("./define.js").ToolDef<{
+    questionId: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    body: z.ZodOptional<z.ZodString>;
+    assigneeEmail: z.ZodOptional<z.ZodNullable<z.ZodEmail>>;
+    dueAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}>;
+export declare const addOption: import("./define.js").ToolDef<{
+    questionId: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}>;
+export declare const updateOption: import("./define.js").ToolDef<{
+    optionId: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    retained: z.ZodOptional<z.ZodBoolean>;
+}>;
+export declare const deleteOption: import("./define.js").ToolDef<{
+    optionId: z.ZodString;
+    confirmed: z.ZodOptional<z.ZodBoolean>;
+}>;
+export declare const deleteQuestion: import("./define.js").ToolDef<{
+    questionId: z.ZodString;
+    confirmed: z.ZodOptional<z.ZodBoolean>;
+}>;
+export declare const addComment: import("./define.js").ToolDef<{
+    dossierId: z.ZodString;
+    body: z.ZodString;
+    questionId: z.ZodOptional<z.ZodString>;
+    entryId: z.ZodOptional<z.ZodString>;
+}>;
+export declare const updateEntry: import("./define.js").ToolDef<{
+    entryId: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    detail: z.ZodOptional<z.ZodString>;
+    value: z.ZodOptional<z.ZodString>;
+    confidence: z.ZodOptional<z.ZodEnum<{
+        established: "established";
+        judgement: "judgement";
+        to_confirm: "to_confirm";
+    }>>;
+    normCode: z.ZodOptional<z.ZodString>;
+    sectionPath: z.ZodOptional<z.ZodString>;
+    page: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    normEdition: z.ZodOptional<z.ZodString>;
+}>;
+export declare const attachEntry: import("./define.js").ToolDef<{
+    entryId: z.ZodString;
+    questionId: z.ZodNullable<z.ZodString>;
+    optionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}>;
 export declare const dossierTools: (import("./define.js").ToolDef<{}> | import("./define.js").ToolDef<{
     name: z.ZodString;
     reference: z.ZodOptional<z.ZodString>;
@@ -152,4 +227,65 @@ export declare const dossierTools: (import("./define.js").ToolDef<{}> | import("
 }> | import("./define.js").ToolDef<{
     dossierId: z.ZodString;
     templateId: z.ZodString;
+}> | import("./define.js").ToolDef<{
+    dossierId: z.ZodString;
+    status: z.ZodOptional<z.ZodEnum<{
+        open: "open";
+        decided: "decided";
+        closed: "closed";
+    }>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+}> | import("./define.js").ToolDef<{
+    questionId: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+}> | import("./define.js").ToolDef<{
+    dossierId: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+}> | import("./define.js").ToolDef<{
+    questionId: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    body: z.ZodOptional<z.ZodString>;
+    assigneeEmail: z.ZodOptional<z.ZodNullable<z.ZodEmail>>;
+    dueAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}> | import("./define.js").ToolDef<{
+    questionId: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}> | import("./define.js").ToolDef<{
+    optionId: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    retained: z.ZodOptional<z.ZodBoolean>;
+}> | import("./define.js").ToolDef<{
+    optionId: z.ZodString;
+    confirmed: z.ZodOptional<z.ZodBoolean>;
+}> | import("./define.js").ToolDef<{
+    questionId: z.ZodString;
+    confirmed: z.ZodOptional<z.ZodBoolean>;
+}> | import("./define.js").ToolDef<{
+    dossierId: z.ZodString;
+    body: z.ZodString;
+    questionId: z.ZodOptional<z.ZodString>;
+    entryId: z.ZodOptional<z.ZodString>;
+}> | import("./define.js").ToolDef<{
+    entryId: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    detail: z.ZodOptional<z.ZodString>;
+    value: z.ZodOptional<z.ZodString>;
+    confidence: z.ZodOptional<z.ZodEnum<{
+        established: "established";
+        judgement: "judgement";
+        to_confirm: "to_confirm";
+    }>>;
+    normCode: z.ZodOptional<z.ZodString>;
+    sectionPath: z.ZodOptional<z.ZodString>;
+    page: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    normEdition: z.ZodOptional<z.ZodString>;
+}> | import("./define.js").ToolDef<{
+    entryId: z.ZodString;
+    questionId: z.ZodNullable<z.ZodString>;
+    optionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }>)[];

package/dist/tools/dossier.js

@@ -358,6 +358,276 @@ export const applyTemplate = defineTool({
         templateId: args.templateId,
     }),
 });
+/* ------------------------------------------------- questions (0.14.0) */
+//
+// Everything the dossier page can read and do to a question (ADR 36). The
+// reads paginate with `cursor`; the two deletions go through the same
+// confirmation gate as `record_decision` (`confirm.ts`), and `confirmed` is
+// read there, never sent.
+const questionStatus = z.enum(['open', 'decided', 'closed']);
+const cursor = (tool) => z.string().min(1).optional().describe(param(tool, 'cursor'));
+const pageLimit = (tool) => z.number().int().min(1).max(200).optional().describe(param(tool, 'limit'));
+export const listQuestions = defineTool({
+    ...headOf('list_questions'),
+    inputSchema: {
+        dossierId: dossierId('list_questions'),
+        status: questionStatus
+            .optional()
+            .describe(param('list_questions', 'status')),
+        limit: pageLimit('list_questions'),
+        cursor: cursor('list_questions'),
+    },
+    run: (client, args) => client.action(api.dossiersApi.listQuestions, {
+        apiKey: requireApiKey(),
+        dossierId: args.dossierId,
+        status: args.status,
+        limit: args.limit,
+        cursor: args.cursor,
+    }),
+});
+export const getQuestion = defineTool({
+    ...headOf('get_question'),
+    inputSchema: {
+        questionId: questionId('get_question'),
+        limit: pageLimit('get_question'),
+        cursor: cursor('get_question'),
+    },
+    run: (client, args) => client.action(api.dossiersApi.getQuestion, {
+        apiKey: requireApiKey(),
+        questionId: args.questionId,
+        limit: args.limit,
+        cursor: args.cursor,
+    }),
+});
+export const getDossierActivity = defineTool({
+    ...headOf('get_dossier_activity'),
+    inputSchema: {
+        dossierId: dossierId('get_dossier_activity'),
+        limit: pageLimit('get_dossier_activity'),
+        cursor: cursor('get_dossier_activity'),
+    },
+    run: (client, args) => client.action(api.dossiersApi.getDossierActivity, {
+        apiKey: requireApiKey(),
+        dossierId: args.dossierId,
+        limit: args.limit,
+        cursor: args.cursor,
+    }),
+});
+export const listExports = defineTool({
+    ...headOf('list_exports'),
+    inputSchema: { dossierId: dossierId('list_exports') },
+    run: (client, args) => client.action(api.dossiersApi.listExports, {
+        apiKey: requireApiKey(),
+        dossierId: args.dossierId,
+    }),
+});
+export const updateQuestion = defineTool({
+    ...headOf('update_question'),
+    inputSchema: {
+        questionId: questionId('update_question'),
+        title: z
+            .string()
+            .min(1)
+            .max(200)
+            .optional()
+            .describe(param('update_question', 'title')),
+        body: z
+            .string()
+            .max(4000)
+            .optional()
+            .describe(param('update_question', 'body')),
+        assigneeEmail: z
+            .email()
+            .nullable()
+            .optional()
+            .describe(param('update_question', 'assigneeEmail')),
+        dueAt: z
+            .string()
+            .regex(/^\d{4}-\d{2}-\d{2}$/)
+            .nullable()
+            .optional()
+            .describe(param('update_question', 'dueAt')),
+    },
+    run: (client, args) => client.action(api.dossiersApi.updateQuestion, {
+        apiKey: requireApiKey(),
+        questionId: args.questionId,
+        title: args.title,
+        body: args.body,
+        assigneeEmail: args.assigneeEmail,
+        dueAt: args.dueAt,
+    }),
+});
+export const addOption = defineTool({
+    ...headOf('add_option'),
+    inputSchema: {
+        questionId: questionId('add_option'),
+        name: z.string().min(1).max(120).describe(param('add_option', 'name')),
+        description: z
+            .string()
+            .max(2000)
+            .optional()
+            .describe(param('add_option', 'description')),
+    },
+    run: (client, args) => client.action(api.dossiersApi.addOption, {
+        apiKey: requireApiKey(),
+        questionId: args.questionId,
+        name: args.name,
+        description: args.description,
+    }),
+});
+const optionId = (tool) => z.string().min(1).describe(param(tool, 'optionId'));
+export const updateOption = defineTool({
+    ...headOf('update_option'),
+    inputSchema: {
+        optionId: optionId('update_option'),
+        name: z
+            .string()
+            .min(1)
+            .max(120)
+            .optional()
+            .describe(param('update_option', 'name')),
+        description: z
+            .string()
+            .max(2000)
+            .optional()
+            .describe(param('update_option', 'description')),
+        retained: z
+            .boolean()
+            .optional()
+            .describe(param('update_option', 'retained')),
+    },
+    run: (client, args) => client.action(api.dossiersApi.updateOption, {
+        apiKey: requireApiKey(),
+        optionId: args.optionId,
+        name: args.name,
+        description: args.description,
+        retained: args.retained,
+    }),
+});
+export const deleteOption = defineTool({
+    ...headOf('delete_option'),
+    inputSchema: {
+        optionId: optionId('delete_option'),
+        confirmed: z
+            .boolean()
+            .optional()
+            .describe(param('delete_option', 'confirmed')),
+    },
+    run: (client, { confirmed: _confirmed, ...args }) => client.action(api.dossiersApi.deleteOption, {
+        apiKey: requireApiKey(),
+        optionId: args.optionId,
+    }),
+});
+export const deleteQuestion = defineTool({
+    ...headOf('delete_question'),
+    inputSchema: {
+        questionId: questionId('delete_question'),
+        confirmed: z
+            .boolean()
+            .optional()
+            .describe(param('delete_question', 'confirmed')),
+    },
+    run: (client, { confirmed: _confirmed, ...args }) => client.action(api.dossiersApi.deleteQuestion, {
+        apiKey: requireApiKey(),
+        questionId: args.questionId,
+    }),
+});
+export const addComment = defineTool({
+    ...headOf('add_comment'),
+    inputSchema: {
+        dossierId: dossierId('add_comment'),
+        body: z.string().min(1).max(4000).describe(param('add_comment', 'body')),
+        questionId: questionId('add_comment').optional(),
+        entryId: z
+            .string()
+            .min(1)
+            .optional()
+            .describe(param('add_comment', 'entryId')),
+    },
+    run: (client, args) => client.action(api.dossiersApi.addComment, {
+        apiKey: requireApiKey(),
+        dossierId: args.dossierId,
+        body: args.body,
+        questionId: args.questionId,
+        entryId: args.entryId,
+    }),
+});
+export const updateEntry = defineTool({
+    ...headOf('update_entry'),
+    inputSchema: {
+        entryId: z.string().min(1).describe(param('update_entry', 'entryId')),
+        title: z
+            .string()
+            .min(1)
+            .max(200)
+            .optional()
+            .describe(param('update_entry', 'title')),
+        detail: z
+            .string()
+            .max(4000)
+            .optional()
+            .describe(param('update_entry', 'detail')),
+        value: z
+            .string()
+            .max(120)
+            .optional()
+            .describe(param('update_entry', 'value')),
+        confidence: z
+            .enum(['established', 'judgement', 'to_confirm'])
+            .optional()
+            .describe(param('update_entry', 'confidence')),
+        normCode: z
+            .string()
+            .max(40)
+            .optional()
+            .describe(param('update_entry', 'normCode')),
+        sectionPath: z
+            .string()
+            .max(60)
+            .optional()
+            .describe(param('update_entry', 'sectionPath')),
+        page: z
+            .number()
+            .int()
+            .positive()
+            .nullable()
+            .optional()
+            .describe(param('update_entry', 'page')),
+        normEdition: z
+            .string()
+            .max(40)
+            .optional()
+            .describe(param('update_entry', 'normEdition')),
+    },
+    run: (client, args) => client.action(api.dossiersApi.updateEntry, {
+        apiKey: requireApiKey(),
+        ...args,
+        entryId: args.entryId,
+    }),
+});
+export const attachEntry = defineTool({
+    ...headOf('attach_entry'),
+    inputSchema: {
+        entryId: z.string().min(1).describe(param('attach_entry', 'entryId')),
+        questionId: z
+            .string()
+            .min(1)
+            .nullable()
+            .describe(param('attach_entry', 'questionId')),
+        optionId: z
+            .string()
+            .min(1)
+            .nullable()
+            .optional()
+            .describe(param('attach_entry', 'optionId')),
+    },
+    run: (client, args) => client.action(api.dossiersApi.attachEntry, {
+        apiKey: requireApiKey(),
+        entryId: args.entryId,
+        questionId: args.questionId,
+        optionId: args.optionId,
+    }),
+});
 export const dossierTools = [
     listDossiers,
     openDossier,
@@ -372,4 +642,16 @@ export const dossierTools = [
     addAttachment,
     listTemplates,
     applyTemplate,
+    listQuestions,
+    getQuestion,
+    getDossierActivity,
+    listExports,
+    updateQuestion,
+    addOption,
+    updateOption,
+    deleteOption,
+    deleteQuestion,
+    addComment,
+    updateEntry,
+    attachEntry,
 ];

package/dist/tools/site.d.ts

@@ -30,6 +30,41 @@ export declare const getBoreholes: import("./define.js").ToolDef<{
     limit: z.ZodOptional<z.ZodNumber>;
     withStrataOnly: z.ZodOptional<z.ZodBoolean>;
 }>;
+/**
+ * The Site tab of a dossier, read by an agent (0.14.0, ADR 36).
+ *
+ * `get_site_context` is the summary shaped for an answer; these are the
+ * record: every fact with its key and notice, the section along the axis,
+ * the map areas, the piezometric contours, the photos, the neighbouring
+ * projects, and the list of sheets. Geometry is left out unless asked for:
+ * a water protection sector runs to hundreds of vertices, and an agent
+ * reads distances, not polygons.
+ */
+export declare const listSites: import("./define.js").ToolDef<{
+    limit: z.ZodOptional<z.ZodNumber>;
+}>;
+export declare const getSite: import("./define.js").ToolDef<{
+    siteId: z.ZodString;
+}>;
+export declare const getSiteSection: import("./define.js").ToolDef<{
+    siteId: z.ZodString;
+    maxPoints: z.ZodOptional<z.ZodNumber>;
+}>;
+export declare const listSiteOverlays: import("./define.js").ToolDef<{
+    siteId: z.ZodString;
+    includeGeometry: z.ZodOptional<z.ZodBoolean>;
+}>;
+export declare const getGroundwaterContours: import("./define.js").ToolDef<{
+    siteId: z.ZodString;
+    includeGeometry: z.ZodOptional<z.ZodBoolean>;
+}>;
+export declare const listSitePhotos: import("./define.js").ToolDef<{
+    siteId: z.ZodString;
+}>;
+export declare const listSiteNeighbours: import("./define.js").ToolDef<{
+    siteId: z.ZodString;
+    radius: z.ZodOptional<z.ZodNumber>;
+}>;
 export declare const siteTools: (import("./define.js").ToolDef<{
     dossierId: z.ZodString;
     address: z.ZodString;
@@ -50,4 +85,15 @@ export declare const siteTools: (import("./define.js").ToolDef<{
      */
     limit: z.ZodOptional<z.ZodNumber>;
     withStrataOnly: z.ZodOptional<z.ZodBoolean>;
+}> | import("./define.js").ToolDef<{
+    limit: z.ZodOptional<z.ZodNumber>;
+}> | import("./define.js").ToolDef<{
+    siteId: z.ZodString;
+    maxPoints: z.ZodOptional<z.ZodNumber>;
+}> | import("./define.js").ToolDef<{
+    siteId: z.ZodString;
+    includeGeometry: z.ZodOptional<z.ZodBoolean>;
+}> | import("./define.js").ToolDef<{
+    siteId: z.ZodString;
+    radius: z.ZodOptional<z.ZodNumber>;
 }>)[];

package/dist/tools/site.js

@@ -97,4 +97,124 @@ export const getBoreholes = defineTool({
         withStrataOnly: args.withStrataOnly,
     }),
 });
-export const siteTools = [scanSite, getSiteContext, getBoreholes];
+const siteId = (tool) => z.string().min(1).describe(param(tool, 'siteId'));
+/**
+ * The Site tab of a dossier, read by an agent (0.14.0, ADR 36).
+ *
+ * `get_site_context` is the summary shaped for an answer; these are the
+ * record: every fact with its key and notice, the section along the axis,
+ * the map areas, the piezometric contours, the photos, the neighbouring
+ * projects, and the list of sheets. Geometry is left out unless asked for:
+ * a water protection sector runs to hundreds of vertices, and an agent
+ * reads distances, not polygons.
+ */
+export const listSites = defineTool({
+    ...headOf('list_sites'),
+    inputSchema: {
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .max(200)
+            .optional()
+            .describe(param('list_sites', 'limit')),
+    },
+    run: (client, args) => client.action(api.sitesApi.listSites, {
+        apiKey: requireApiKey(),
+        limit: args.limit,
+    }),
+});
+export const getSite = defineTool({
+    ...headOf('get_site'),
+    inputSchema: { siteId: siteId('get_site') },
+    run: (client, args) => client.action(api.sitesApi.getSite, {
+        apiKey: requireApiKey(),
+        siteId: args.siteId,
+    }),
+});
+export const getSiteSection = defineTool({
+    ...headOf('get_site_section'),
+    inputSchema: {
+        siteId: siteId('get_site_section'),
+        maxPoints: z
+            .number()
+            .int()
+            .min(2)
+            .max(200)
+            .optional()
+            .describe(param('get_site_section', 'maxPoints')),
+    },
+    run: (client, args) => client.action(api.sitesApi.getSiteSection, {
+        apiKey: requireApiKey(),
+        siteId: args.siteId,
+        maxPoints: args.maxPoints,
+    }),
+});
+export const listSiteOverlays = defineTool({
+    ...headOf('list_site_overlays'),
+    inputSchema: {
+        siteId: siteId('list_site_overlays'),
+        includeGeometry: z
+            .boolean()
+            .optional()
+            .describe(param('list_site_overlays', 'includeGeometry')),
+    },
+    run: (client, args) => client.action(api.sitesApi.listSiteOverlays, {
+        apiKey: requireApiKey(),
+        siteId: args.siteId,
+        includeGeometry: args.includeGeometry,
+    }),
+});
+export const getGroundwaterContours = defineTool({
+    ...headOf('get_groundwater_contours'),
+    inputSchema: {
+        siteId: siteId('get_groundwater_contours'),
+        includeGeometry: z
+            .boolean()
+            .optional()
+            .describe(param('get_groundwater_contours', 'includeGeometry')),
+    },
+    run: (client, args) => client.action(api.sitesApi.getGroundwaterContours, {
+        apiKey: requireApiKey(),
+        siteId: args.siteId,
+        includeGeometry: args.includeGeometry,
+    }),
+});
+export const listSitePhotos = defineTool({
+    ...headOf('list_site_photos'),
+    inputSchema: { siteId: siteId('list_site_photos') },
+    run: (client, args) => client.action(api.sitesApi.listSitePhotos, {
+        apiKey: requireApiKey(),
+        siteId: args.siteId,
+    }),
+});
+export const listSiteNeighbours = defineTool({
+    ...headOf('list_site_neighbours'),
+    inputSchema: {
+        siteId: siteId('list_site_neighbours'),
+        radius: z
+            .number()
+            .int()
+            .min(50)
+            .max(5000)
+            .optional()
+            .describe(param('list_site_neighbours', 'radius')),
+    },
+    run: (client, args) => client.action(api.sitesApi.listSiteNeighbours, {
+        apiKey: requireApiKey(),
+        siteId: args.siteId,
+        radius: args.radius,
+    }),
+});
+export const siteTools = [
+    scanSite,
+    getSiteContext,
+    getBoreholes,
+    listSites,
+    getSite,
+    getSiteSection,
+    listSiteOverlays,
+    getGroundwaterContours,
+    listSitePhotos,
+    listSiteNeighbours,
+];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stratta/mcp",
   "mcpName": "ch.stratta/mcp",
-  "version": "0.13.1",
+  "version": "0.14.0",
   "description": "MCP server exposing the engineering norms your firm is licensed for (SIA / Eurocodes) to any MCP client, via Stratta TreeRAG.",
   "license": "UNLICENSED",
   "author": "SmartFlow <hello@stratta.ch>",

package/skills/consult-stratta/SKILL.md

@@ -46,7 +46,7 @@ A conversation disappears, a project lasts months. The dossier is what remains:
 
 **Open one** (`open_dossier`) when the user names a project, a structure, a site or a mandate, when a value is retained for a design rather than looked up, when a hypothesis is set, when a site observation is reported, or when a question is left open. Do not open a dossier for a one-off lookup with no project behind it.
 
-**Reload it first** (`list_dossiers`, `load_dossier`) BEFORE answering, as soon as the user returns to a project already named ("pick up dossier X", "where were we on Y"): reloading is what stops a decision already taken from being taken again. Read its entries and its open questions before answering anything about that project.
+**Reload it first** (`list_dossiers`, `load_dossier`) BEFORE answering, as soon as the user returns to a project already named ("pick up dossier X", "where were we on Y"): reloading is what stops a decision already taken from being taken again. Read its entries and its open questions before answering anything about that project. To work on one question, `get_question` reads it in full (options, evidence with every citation field, comments); `attach_entry` files what `load_dossier` lists as unclassified. A question is edited with `update_question`, never deleted unless the user says so.
 
 **Read its attachments.** A dossier carries the project's own documents (site reports, borehole logs, meeting minutes): `list_attachments`, then `read_attachment` on what bears on the question, or `search_in_dossier` when the dossier holds many. A fact from a piece is evidence like a clause: cite it as [name, p. N] and file it with `attachmentId` and `attachmentPage`.