@theronap/cortex-mcp 0.9.51 → 0.9.52

package/lib/server.mjs

@@ -808,6 +808,38 @@ export async function runServer(version) {
     },
   )
 
+  server.registerTool(
+    'my_day',
+    {
+      title: 'My daily log (chronological)',
+      description: "Your OWN activity for a day, composed chronologically from that day's records of every kind — sessions, meetings, comms, docs, notes. The \"what did I do today\" rollup: a derived view over records (nothing new is stored), self-scoped to you, each item tagged with its kind. Defaults to today in your local timezone. Pass `date` (YYYY-MM-DD) for another day, or `days` for a trailing window (e.g. days:7 for the week). Confidential records are segregated into their own block.",
+      inputSchema: {
+        date: z.string().optional().describe('the day to roll up, YYYY-MM-DD (default: today in your local timezone)'),
+        days: z.number().optional().describe('trailing window ending on `date` — e.g. 7 for the past week (default 1, max 31)'),
+      },
+    },
+    async ({ date, days }) => {
+      // Resolve the caller's local timezone + today client-side (the MCP server runs on the user's
+      // machine) so the day boundary matches their wall clock, not the server's UTC.
+      const tz = Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC'
+      const today = new Date().toLocaleDateString('en-CA', { timeZone: tz }) // en-CA → YYYY-MM-DD
+      const qs = new URLSearchParams({ date: date || today, tz })
+      if (days != null) qs.set('days', String(days))
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/records/daily?${qs}`, { headers: { Authorization: `Bearer ${TOKEN}` } })
+      } catch (e) {
+        return { content: [{ type: 'text', text: `Could not build daily log: ${e.message}` }] }
+      }
+      if (!res.ok) {
+        const d = classify(res.status, res.headers.get('content-type'), await res.text(), res.headers.get('x-vercel-id'))
+        return { content: [{ type: 'text', text: `Could not build daily log: ${d.message}` }] }
+      }
+      const { text } = await res.json()
+      return { content: [{ type: 'text', text }] }
+    },
+  )
+
   server.registerTool(
     'my_sessions',
     {

package/package.json

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

package/skills/log/SKILL.md

@@ -52,6 +52,28 @@ No arguments. Read the conversation context.
    docs are pending, follow the `cortex-author-docs` skill (author each into its page, then
    `docs-scan --mark`). Specs/plans written to disk this session must not die on disk — a spec IS
    a page. If no roots are registered or nothing is pending, skip silently.
+7. **Reconcile & verify (prove the sweep — don't trust it).** Step 5 relies on your in-the-moment
+   judgment of "what advanced"; this step closes the loop so nothing is silently missed and no stale
+   write slips through. Before printing the Output:
+   a. **Enumerate what you touched** — from the transcript, list the concrete entities this session
+      advanced: the project(s), notable files/artifacts, and the people you coordinated with. Derive
+      this checklist from what actually *happened*, not from what you remember authoring — the whole
+      point is to catch the node you forgot.
+   b. **Assert one outcome per entity** — every item gets exactly `authored [[Page]]` **or**
+      `skipped — <reason>` (e.g. "no material change", "not a node", "already current"). Nothing may be
+      left unaccounted for. If an entity that genuinely advanced has neither, `author` it now (Step 5).
+   c. **Verify the writes landed and are right** — for each page you claim you authored, `read_page` it
+      (or check `page_history`) and confirm both: (i) **the change applied** — an `author` that returned
+      "no change" when you *intended* an update means it did NOT land (stale `base_version`, wrong
+      brain/namespace, or nothing actually differed) — re-check rather than assume; and (ii) **the page
+      reflects THIS session's first-hand findings**, not a prior you copied forward. This is the
+      read-after-write half of the read-before-write rule — the guard against laundering stale priors
+      into the wiki. Fix a page you can edit; `set_page_validity` on one you can't. (Cross-brain note:
+      `read_page` can resolve a page in another brain that `author` won't write — if a "verify" read
+      looks right but your write reported no-op, run `my_brains` / check `authoring_context` before
+      trusting the read.)
+   Carry the tally into the Output. If any intended write did not land, say so — never report a clean
+   sweep you didn't confirm.
 
 ## Output
 
@@ -66,6 +88,7 @@ After calling `log_session`, show a short structured summary:
 **Coordinated with:** people involved
 **Logged:** ✅ persisted as the session's record (authoritative)  (or ⚠ log_session errored — run doctor)
 **Wiki authored:** [[Node A]], [[Node B]] — pages updated (or "— nothing advanced this session")
+**Reconciled:** N touched → M authored, K skipped (reason each); writes verified ✅ (or ⚠ <what didn't land>)
 ```
 
 ## Safety rules