@theronap/cortex-mcp 0.9.30 → 0.9.32

package/lib/server.mjs

@@ -517,6 +517,187 @@ export async function runServer(version) {
     },
   )
 
+  server.registerTool(
+    'set_page_privacy',
+    {
+      title: 'Change who can see a wiki page',
+      description: 'Re-tier a wiki page you own or may edit: "accessible" (anyone in the org), "scoped" (owner + their management chain), or "confidential" (owner only, plus explicit grants). Demoting a PROJECT page also demotes its evidence records (demote-only; each record\'s owner is notified and can revert). Promotions never touch records. If the target tier already has a page, you\'ll be asked to merge via author first, then re-run with absorb=true. Org admins may demote any page, never promote.',
+      inputSchema: {
+        kind: z.enum(['project', 'person', 'org', 'user']).describe('the page kind'),
+        name: z.string().describe('the exact page name'),
+        tier: z.enum(['accessible', 'scoped', 'confidential']).describe('the new visibility tier'),
+        source_tier: z.enum(['accessible', 'scoped', 'confidential']).optional().describe('when the node has multiple tier variants: which one to move'),
+        absorb: z.boolean().optional().describe('after merging your content into an existing target-tier page via author: true removes your now-absorbed source variant'),
+      },
+    },
+    async ({ kind, name, tier, source_tier, absorb }) => {
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/brain/page-privacy`, {
+          method: 'POST',
+          headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
+          body: JSON.stringify({ kind, name, tier, ...(source_tier ? { source_tier } : {}), ...(absorb ? { absorb: true } : {}) }),
+        })
+      } catch (e) {
+        return { content: [{ type: 'text', text: `Could not set page privacy: ${e.message}` }] }
+      }
+      const out = await res.json().catch(() => null)
+      if (!res.ok) {
+        // 409s carry the collision protocol (merge instruction, both variants when readable) —
+        // surface the server's structured message verbatim so the agent can follow it.
+        if (out?.error) {
+          const extra = out.collision === 'readable' && out.blocking
+            ? `\nYour ${out.source?.tier} page: ${out.source?.summary ?? out.source?.title}\nExisting ${out.blocking.tier} page: ${out.blocking.summary ?? out.blocking.title}`
+            : ''
+          return { content: [{ type: 'text', text: `Could not set page privacy: ${out.error}${extra}` }] }
+        }
+        const d = classify(res.status, res.headers.get('content-type'), '', res.headers.get('x-vercel-id'))
+        return { content: [{ type: 'text', text: `Could not set page privacy: ${d.message}` }] }
+      }
+      const g = out.live_grants?.length
+        ? ` Grants still active for: ${out.live_grants.map((x) => x.grantee_name ?? x.grantee_user_id).join(', ')}.`
+        : ''
+      return { content: [{ type: 'text', text: `Done — "${out.moved.title}" moved ${out.moved.from} → ${out.moved.to}.${out.ownership_taken ? ' (You took ownership of this previously owner-less page.)' : ''} ${out.note}${g}` }] }
+    },
+  )
+
+  server.registerTool(
+    'grant_page_access',
+    {
+      title: 'Grant or revoke a specific person\'s access to your page',
+      description: 'Share one of YOUR non-accessible wiki pages with a specific org member (or take that access back). A grant lets exactly that person read the page even though its tier would hide it — the escape hatch for "confidential, but Dana needs it". Owner-only. Grants survive re-tiering: revoke them when they should end.',
+      inputSchema: {
+        kind: z.enum(['project', 'person', 'org', 'user']).describe('the page kind'),
+        name: z.string().describe('the exact page name'),
+        grantee: z.string().describe('the org member\'s display name or email (must resolve uniquely — use email if ambiguous)'),
+        action: z.enum(['grant', 'revoke']).describe('grant or revoke'),
+        tier: z.enum(['scoped', 'confidential']).optional().describe('which variant (default: the most restrictive one)'),
+      },
+    },
+    async ({ kind, name, grantee, action, tier }) => {
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/brain/page-grants`, {
+          method: 'POST',
+          headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
+          body: JSON.stringify({ kind, name, grantee, action, ...(tier ? { tier } : {}) }),
+        })
+      } catch (e) {
+        return { content: [{ type: 'text', text: `Could not ${action}: ${e.message}` }] }
+      }
+      const out = await res.json().catch(() => null)
+      if (!res.ok) return { content: [{ type: 'text', text: `Could not ${action}: ${out?.error ?? res.status}` }] }
+      const verb = { granted: 'now has access to', already_granted: 'already had access to', revoked: 'no longer has access to', not_granted: 'had no grant on' }[out.action]
+      return { content: [{ type: 'text', text: `Done — ${out.grantee} ${verb} the ${out.tier} page.` }] }
+    },
+  )
+
+  server.registerTool(
+    'list_page_grants',
+    {
+      title: 'List who has granted access to your page',
+      description: 'Show every explicit access grant on YOUR page\'s tier variants (owner-only). Use after re-tiering a page — grants survive tier changes and keep granting until revoked.',
+      inputSchema: {
+        kind: z.enum(['project', 'person', 'org', 'user']).describe('the page kind'),
+        name: z.string().describe('the exact page name'),
+      },
+    },
+    async ({ kind, name }) => {
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/brain/page-grants?kind=${encodeURIComponent(kind)}&name=${encodeURIComponent(name)}`, {
+          headers: { Authorization: `Bearer ${TOKEN}` },
+        })
+      } catch (e) {
+        return { content: [{ type: 'text', text: `Could not list grants: ${e.message}` }] }
+      }
+      const out = await res.json().catch(() => null)
+      if (!res.ok) return { content: [{ type: 'text', text: `Could not list grants: ${out?.error ?? res.status}` }] }
+      if (!out.grants?.length) return { content: [{ type: 'text', text: 'No grants on this page.' }] }
+      const lines = out.grants.map((g) => `- ${g.grantee_name ?? g.grantee_user_id} → ${g.tier} variant (since ${String(g.created_at).slice(0, 10)})`)
+      return { content: [{ type: 'text', text: `Grants (${out.grants.length}):\n${lines.join('\n')}` }] }
+    },
+  )
+
+  server.registerTool(
+    'my_retier_notices',
+    {
+      title: 'Records of yours that a page demotion re-tiered',
+      description: 'When someone demotes a project page, its evidence records follow (demote-only) — including yours. This lists those notices (newest first) and marks them seen. To undo one, call set_record_privacy with the record_id and its previous tier (shown as from_privacy).',
+      inputSchema: {},
+    },
+    async () => {
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/brain/retier-notices`, { headers: { Authorization: `Bearer ${TOKEN}` } })
+      } catch (e) {
+        return { content: [{ type: 'text', text: `Could not list notices: ${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 list notices: ${d.message}` }] }
+      }
+      const { notices } = await res.json()
+      if (!notices?.length) return { content: [{ type: 'text', text: 'No re-tier notices.' }] }
+      const lines = notices.map((n) =>
+        `- record ${n.record_id} ("${n.record_title ?? 'untitled'}") ${n.from_privacy} → ${n.to_privacy} — ${n.demoted_by_name ?? 'someone'} demoted the ${n.node_name ?? n.node_kind} page. Revert: set_record_privacy(record_id, "${n.from_privacy}").`)
+      return { content: [{ type: 'text', text: `Your re-tiered records (${notices.length}):\n${lines.join('\n')}` }] }
+    },
+  )
+
+  server.registerTool(
+    'page_merge_requests',
+    {
+      title: 'Merge requests on pages you own',
+      description: 'Someone tried to move their page into a tier slot your page occupies (they only saw "slot occupied"). Review pending requests here; read their variant, merge anything worth keeping into your page via author, then decide with decide_page_merge.',
+      inputSchema: {},
+    },
+    async () => {
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/brain/page-merge-requests`, { headers: { Authorization: `Bearer ${TOKEN}` } })
+      } catch (e) {
+        return { content: [{ type: 'text', text: `Could not list merge requests: ${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 list merge requests: ${d.message}` }] }
+      }
+      const { requests } = await res.json()
+      if (!requests?.length) return { content: [{ type: 'text', text: 'No pending page merge requests.' }] }
+      const lines = requests.map((q) =>
+        `- [${q.id}] ${q.requester_name ?? 'someone'} wants their ${q.kind} page merged into your ${q.requested_tier} "${q.page_title}". Merge via author first, then decide_page_merge.`)
+      return { content: [{ type: 'text', text: `Pending page merge requests (${requests.length}):\n${lines.join('\n')}` }] }
+    },
+  )
+
+  server.registerTool(
+    'decide_page_merge',
+    {
+      title: 'Approve or deny a page merge request',
+      description: 'Decide a pending page merge request you own. IMPORTANT: approve only AFTER you have merged whatever of the requester\'s content you want into your page (via author) — approving DELETES their variant of the node. Deny closes the request and nothing moves.',
+      inputSchema: {
+        id: z.string().describe('the request id from page_merge_requests'),
+        decision: z.enum(['approve', 'deny']).describe('approve = their variant is removed (merge first!); deny = nothing moves'),
+      },
+    },
+    async ({ id, decision }) => {
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/brain/page-merge-requests`, {
+          method: 'POST',
+          headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
+          body: JSON.stringify({ id, decision }),
+        })
+      } catch (e) {
+        return { content: [{ type: 'text', text: `Could not decide: ${e.message}` }] }
+      }
+      const out = await res.json().catch(() => null)
+      if (!res.ok) return { content: [{ type: 'text', text: `Could not decide: ${out?.error ?? res.status}` }] }
+      return { content: [{ type: 'text', text: out.decision === 'denied' ? 'Denied — nothing moved.' : `Approved — removed variant(s): ${out.removed_variants.join(', ') || 'none remained'}. ${out.note}` }] }
+    },
+  )
+
   // ── File requests: ask the owner for a record's FULL original (lives on their machine) ──
   const fail = (verb, res) => async () =>
     ({ content: [{ type: 'text', text: `Could not ${verb}: ${classify(res.status, res.headers.get('content-type'), await res.text(), res.headers.get('x-vercel-id')).message}` }] })
@@ -688,12 +869,14 @@ export async function runServer(version) {
           heading: z.string().describe('e.g. Overview, Current state, Decisions, Open threads, People'),
           body: z.string().describe('dense markdown WITH inline [[links]] where the prose references another node'),
         })).describe('3-5 sections; the page body'),
-        tier: z.enum(['accessible', 'scoped', 'confidential']).optional().describe('visibility tier (default accessible — the shareable page)'),
+        tier: z.enum(['accessible', 'scoped', 'confidential']).optional().describe('visibility tier. Omit for the safe default: scoped (you + your management chain) on nodes that support it — your user page, projects you own-scope — and accessible elsewhere (person/org pages are the shared wiki). Pass accessible explicitly when the page is meant for the whole org.'),
         base_version: z.string().optional().describe('the `version` hash shown when you read this page (read_page) — REQUIRED when updating an existing page, so a concurrent edit is caught instead of clobbered. Omit only for a brand-new node. If the save returns "stale" or "read first", read_page again and retry with the fresh version.'),
       },
     },
     async ({ kind, name, summary, sections, tier, base_version }) => {
-      const pages = [{ tier: tier ?? 'accessible', summary, base_version, sections: Array.isArray(sections) ? sections : [] }]
+      // No client-side tier default — the server computes the per-kind safe default (page-privacy
+      // T4/D10) so version-pinned installs can't bake a stale policy.
+      const pages = [{ ...(tier ? { tier } : {}), summary, base_version, sections: Array.isArray(sections) ? sections : [] }]
       let res
       try {
         res = await fetchCortex(`${BASE}/api/brain/author`, {

package/lib/setup.mjs

@@ -61,6 +61,28 @@ function ensureDir(path) {
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true })
 }
 
+// Merge the capture Stop hook into a Codex hooks.json object. Pure + idempotent: drops any prior
+// cortex capture entry (old token / old path / old pinned version) before appending the current one,
+// so re-running never duplicates and never leaves a stale version pinned behind a live one.
+// Mirrors the Claude Stop-hook merge in step 2 below, minus the SessionStart/PreCompact hooks Codex
+// doesn't support (confirmed: Codex's hook runtime only recognizes PreToolUse/PostToolUse/PreCompact/
+// UserPromptSubmit/Stop — no SessionStart, so status/skills-repair/snapshot-context stay Claude-only).
+export function mergeCodexHooks(existing, captureCmd) {
+  const h = existing && typeof existing === 'object' ? existing : {}
+  h.hooks = h.hooks && typeof h.hooks === 'object' ? h.hooks : {}
+  h.hooks.Stop = Array.isArray(h.hooks.Stop) ? h.hooks.Stop : []
+  for (const grp of h.hooks.Stop) {
+    if (Array.isArray(grp.hooks)) {
+      grp.hooks = grp.hooks.filter((c) => !/cortex-mcp.*capture|capture-session-cloud/.test(c.command ?? ''))
+    }
+  }
+  let grp = h.hooks.Stop.find((g) => (g.matcher ?? '') === '')
+  if (!grp) { grp = { matcher: '', hooks: [] }; h.hooks.Stop.push(grp) }
+  grp.hooks = grp.hooks ?? []
+  grp.hooks.push({ type: 'command', command: captureCmd })
+  return h
+}
+
 export async function runSetup(argv, version) {
   const token = argv[0]
   if (!token || token.startsWith('-')) {
@@ -110,7 +132,7 @@ export async function runSetup(argv, version) {
 
   // ── 1b. MCP server in Codex (~/.codex/config.toml), only if Codex is installed ──
   // Codex gets the same Cortex context tools as Claude Code. Non-fatal: a Codex hiccup must
-  // never block the primary Claude wiring. Capture/skills self-heal stay Claude-driven for now.
+  // never block the primary Claude wiring.
   const codexDir = join(home, '.codex')
   if (existsSync(codexDir)) {
     try {
@@ -122,6 +144,25 @@ export async function runSetup(argv, version) {
     } catch (e) {
       log(`  ⚠ Codex MCP wiring skipped: ${e.message} (Claude wiring unaffected)`)
     }
+
+    // ── 1c. Capture Stop hook in Codex (~/.codex/hooks.json) ──
+    // Without this, Codex sessions get context tools + skills but never capture — a silent gap
+    // (found 2026-07-02: a hand-set hook on Theron's machine was pinned to a stale 0.4.5, years
+    // behind `stable`, because nothing in setup/repair ever refreshed it). Same idempotent
+    // merge pattern as the Claude Stop hook below; non-fatal on failure.
+    try {
+      const codexHooks = join(codexDir, 'hooks.json')
+      let existingHooks
+      try { existingHooks = readJson(codexHooks) } catch { existingHooks = {} } // malformed → start fresh, don't block
+      const bak = backup(codexHooks)
+      const captureCmd = `CORTEX_TOKEN=${token} npx -y ${spec} capture`
+      ensureDir(codexHooks)
+      writeFileSync(codexHooks, JSON.stringify(mergeCodexHooks(existingHooks, captureCmd), null, 2))
+      log(`  ✓ Capture hook → ${codexHooks}${bak ? ' (backup saved)' : ''}`)
+      log('     Codex will ask you to re-approve this hook once (it hashes hooks.json for tamper-detection).')
+    } catch (e) {
+      log(`  ⚠ Codex capture hook skipped: ${e.message} (Claude wiring unaffected)`)
+    }
   }
 
   // ── 2. Capture Stop hook in ~/.claude/settings.json ──────────────────────

package/package.json

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