@theronap/cortex-mcp 0.9.130 → 0.9.132

package/lib/server.mjs

@@ -2167,6 +2167,111 @@ function renderNudge(payload) {
     },
   )
 
+  server.registerTool(
+    'propose_containers',
+    {
+      title: 'Which event could this record belong to?',
+      description: "Given a record, list the events (class sessions, meetings) it could have COME FROM — candidates only, nothing is written. Candidates are generated by time overlap and filtered by whether the container's type admits that kind of record; a CLOSED container still qualifies, because closing seals a candidate set but does not stop admitting (a transcript synced days later still belongs to the meeting it came from). ⚠ OVERLAP IS NOT AN ANSWER: a coding session that overlapped a meeting may be evidence you SKIPPED it. Ranked by how TIGHT the container is, ascending — a point in a 50-minute class is specific evidence, the same point in an all-day event is nearly none. Choose, then call contain_record.",
+      inputSchema: {
+        record_id: z.string().describe('the record to place'),
+        limit: z.number().optional().describe('max candidates (default 10)'),
+      },
+    },
+    async ({ record_id, limit }) => {
+      const qs = new URLSearchParams(limit ? { limit: String(limit) } : {})
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/records/${encodeURIComponent(record_id)}/containers?${qs}`,
+          { headers: { Authorization: `Bearer ${TOKEN}` } })
+      } catch (e) {
+        return toolError(`Could not reach Agnoclast to find containers for ${record_id}: ${e.message}`)
+      }
+      const body = await res.json().catch(() => ({}))
+      if (!res.ok || !body?.ok) return toolError(`Could not propose containers: ${body?.error ?? res.status}`)
+      if (!body.proposals?.length) {
+        return { content: [{ type: 'text', text: `No container candidates for ${record_id}. Either nothing overlaps its time, or no overlapping event's type admits this kind of record.` }] }
+      }
+      const lines = [`Container candidates for ${record_id} (tightest first):`]
+      for (const p of body.proposals) {
+        lines.push(`- ${p.title ?? '(untitled)'} · ${p.containerType} · ${p.containerMinutes}min · starts ${p.startsAt}`
+          + `\n    id: ${p.containerRecordId}${p.late ? '\n    LATE — this arrived after the container closed; still a valid home' : ''}`)
+      }
+      lines.push('', 'Nothing has been written. Use contain_record with the id you choose.')
+      return { content: [{ type: 'text', text: lines.join('\n') }] }
+    },
+  )
+
+  server.registerTool(
+    'contain_record',
+    {
+      title: 'Place a record inside an event',
+      description: "Put a record INSIDE an event — the transcript that came out of a meeting, the session that filled a work block. This is a DECISION, not an inference, and it is recorded as one (designated_by: human). ⚠ It only accepts a container that propose_containers actually offered for this record: naming an arbitrary id would skip the checks that keep containment inside one brain and inside the container type's admission set. `kind` defaults to 'produced' (it came OUT of that event); use 'context' for something that was merely going on at the time. Placing a record in an event is different from attaching it to a PAGE: pages are what a record is ABOUT, containers are where it CAME FROM.",
+      inputSchema: {
+        record_id: z.string().describe('the record to place'),
+        container_record_id: z.string().describe('the event to place it in — an id from propose_containers or find_sessions'),
+        kind: z.enum(['produced', 'context']).optional().describe("'produced' (default) = it came out of that event; 'context' = it was merely happening at the same time"),
+      },
+    },
+    async ({ record_id, container_record_id, kind }) => {
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/records/${encodeURIComponent(record_id)}/containers`, {
+          method: 'POST',
+          headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
+          body: JSON.stringify({ containerRecordId: container_record_id, kind }),
+        })
+      } catch (e) {
+        return toolError(`Could not reach Agnoclast to place ${record_id}: ${e.message}`)
+      }
+      const body = await res.json().catch(() => ({}))
+      if (!res.ok || !body?.ok) {
+        return toolError(`Could not place ${record_id}: ${body?.error ?? res.status}${body?.detail ? ` — ${body.detail}` : ''}`)
+      }
+      // `contained: false` means it was ALREADY in that container — a no-op, not a failure. Saying
+      // "placed" either way would hide that a second call did nothing.
+      return { content: [{ type: 'text', text: body.contained
+        ? `Placed ${record_id} inside ${container_record_id} as '${kind ?? 'produced'}'.`
+        : `${record_id} was already inside ${container_record_id} — nothing changed.` }] }
+    },
+  )
+
+  server.registerTool(
+    'find_sessions',
+    {
+      title: 'Find the calendar sessions on a given day',
+      description: "Find the event records on a local calendar day — how you get the id of a SPECIFIC session (\"the Wednesday MSB 380 class\") so you can place something inside it with capture_record's container_record_id. Pass `tz` as the person's own timezone: a day means the day THEY lived through, and resolving it in UTC puts an evening class on the wrong date. Each result says whether it has a CONTAINER — a session with `container_type: null` cannot hold anything, and naming it as a target fails later for a reason you could not otherwise have seen.",
+      inputSchema: {
+        date: z.string().describe('the local calendar day, YYYY-MM-DD'),
+        tz: z.string().optional().describe("the person's IANA timezone, e.g. America/Denver. Defaults to UTC, which is usually NOT what you want."),
+        q: z.string().optional().describe('case-insensitive title filter, e.g. "MSB 380"'),
+      },
+    },
+    async ({ date, tz, q }) => {
+      const qs = new URLSearchParams({ date, ...(tz ? { tz } : {}), ...(q ? { q } : {}) })
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/sessions?${qs}`, { headers: { Authorization: `Bearer ${TOKEN}` } })
+      } catch (e) {
+        return toolError(`Could not reach Agnoclast to find sessions on ${date}: ${e.message}`)
+      }
+      const body = await res.json().catch(() => ({}))
+      if (!res.ok || !body?.ok) return toolError(`Could not find sessions on ${date}: ${body?.error ?? res.status}`)
+      if (!body.sessions?.length) {
+        return { content: [{ type: 'text', text: `No sessions on ${date}${q ? ` matching "${q}"` : ''}${tz ? ` (${tz})` : ' (UTC — pass tz if that is wrong)'}.` }] }
+      }
+      const lines = [`Sessions on ${date}${tz ? ` (${tz})` : ' (UTC)'}:`]
+      for (const s of body.sessions) {
+        const when = new Date(s.startsAt).toISOString().slice(11, 16)
+        const box = s.containerType
+          ? `container: ${s.containerType}${s.sealed ? ', sealed' : ''}${s.alreadyContains ? `, holds ${s.alreadyContains}` : ''}`
+          : '⚠ NO CONTAINER — cannot hold anything'
+        lines.push(`- ${s.title ?? '(untitled)'} · ${when}Z${s.location ? ` · ${s.location}` : ''}\n    id: ${s.recordId}\n    ${box}${s.seriesKey ? `\n    series: ${s.seriesKey}` : ''}`)
+      }
+      lines.push('', 'Use an id as capture_record\'s container_record_id to place something inside that session.')
+      return { content: [{ type: 'text', text: lines.join('\n') }] }
+    },
+  )
+
   server.registerTool(
     'capture_record',
     {
@@ -2202,6 +2307,18 @@ function renderNudge(payload) {
       if (!res.ok || !body?.ok) {
         return toolError(`Could not capture "${title}": ${body?.error ?? res.status}${body?.detail ? ` — ${body.detail}` : ''}`)
       }
+      // ⚠ A SEALED UNIT IS NOT A RECORD YET, AND SAYING "captured" WOULD BE A LIE OF OMISSION.
+      // On a private-intake account the content is stored encrypted and becomes a record only when
+      // materialised — so it cannot be found, routed or contained until then. Reporting it as a
+      // plain success is how someone believes a transcript is filed when it is sitting sealed.
+      if (body.sealed) {
+        const l = [`Stored "${title}" as a SEALED private-intake unit (${body.intakeItemId}).`]
+        l.push('It is NOT a record yet — it becomes one when you materialise it, and only then can it be routed or placed in a container.')
+        if (body.duplicate) l.push('This matched an existing unit rather than creating a new one.')
+        if (body.routed_by?.length) l.push(`Carries: ${body.routed_by.join(', ')} — it will route on those once materialised.`)
+        else l.push('⚠ NO IDENTIFIERS — once materialised it will reach no page.')
+        return { content: [{ type: 'text', text: l.join('\n') }] }
+      }
       const lines = [`Captured "${title}" as record ${body.id}.`]
       // ⚠ AN UNROUTED RECORD IS REPORTED AS SUCH. It was stored, but nothing will find it — reporting
       // that as a plain success is how a record becomes invisible while looking filed.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@theronap/cortex-mcp",
-  "version": "0.9.130",
+  "version": "0.9.132",
   "description": "Connect your AI assistant to Cortex — your org's projects, activity, gaps, and directives, scoped to you.",
   "type": "module",
   "bin": {