@stratta/mcp 0.13.1 → 0.15.0

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/ingest.d.ts

@@ -77,6 +77,7 @@ export declare const ingestPublish: import("./define.js").ToolDef<{
 }>;
 export declare const ingestDelete: import("./define.js").ToolDef<{
     documentId: z.ZodString;
+    confirmed: z.ZodOptional<z.ZodBoolean>;
 }>;
 export declare const ingestTools: (import("./define.js").ToolDef<{
     code: z.ZodString;
@@ -145,4 +146,7 @@ export declare const ingestTools: (import("./define.js").ToolDef<{
 }> | import("./define.js").ToolDef<{
     documentId: z.ZodString;
     force: z.ZodOptional<z.ZodBoolean>;
+}> | import("./define.js").ToolDef<{
+    documentId: z.ZodString;
+    confirmed: z.ZodOptional<z.ZodBoolean>;
 }>)[];

package/dist/tools/ingest.js

@@ -8,8 +8,10 @@ import { defineTool } from './define.js';
  * its Stratta workspace, from the user's own agent. Every call is
  * authenticated by the user's API key and scoped server-side to their
  * organisation (see convex/ingestionApi.ts). Driven by the `ingest-norm`
- * skill. Absent from the remote transport on purpose: the pipeline starts
- * with a PDF on the caller's disk.
+ * skill. ⚠️ They are served on the remote connector too since 2026-09-05
+ * (`convex/mcpIngestRegistrations.ts`): the pre-pass still reads a PDF on the
+ * caller's disk, which rules out a browser client but not Claude Code, Codex,
+ * Cursor or Gemini CLI.
  *
  * Names, descriptions and annotations come from the generated catalogue. The
  * Zod shapes below are enforced by the SDK before a handler runs, so a bad
@@ -232,7 +234,14 @@ export const ingestPublish = defineTool({
 });
 export const ingestDelete = defineTool({
     ...headOf('ingest_delete'),
-    inputSchema: { documentId: documentId('ingest_delete') },
+    inputSchema: {
+        documentId: documentId('ingest_delete'),
+        // Read by the confirmation gate in `confirm.ts`, never sent on.
+        confirmed: z
+            .boolean()
+            .optional()
+            .describe(param('ingest_delete', 'confirmed')),
+    },
     run: async (client, args) => {
         await client.action(api.ingestionApi.deleteDocument, {
             apiKey: requireApiKey(),

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.15.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`.