robrain 2.3.7 → 2.3.9

package/vendor/codex-hooks/lib.mjs

@@ -0,0 +1,276 @@
+// plugins/claude-code/hooks/lib.mjs
+// ─────────────────────────────────────────────────────────────
+// Shared plumbing for RoBrain Claude Code plugin hooks.
+//
+// Design constraints:
+//  - Zero dependencies, Node >= 18 (built-in fetch). Hooks must start fast.
+//  - Fail-open ALWAYS: a dead Perception, missing config, or timeout must
+//    never block or break the user's Claude Code session. Hooks print nothing
+//    and exit 0 on any failure.
+//  - Thin client: raw turns go to Perception POST /signals with
+//    needs_classification=true — classification/extraction/dedup happen
+//    server-side, so this plugin (and future Codex/Cursor ports) stays dumb.
+// ─────────────────────────────────────────────────────────────
+
+import { createHash } from 'node:crypto'
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+/** Read all of stdin (the hook input JSON). */
+export async function readStdin() {
+  const chunks = []
+  for await (const chunk of process.stdin) chunks.push(chunk)
+  return Buffer.concat(chunks).toString('utf8')
+}
+
+export function parseHookInput(raw) {
+  try {
+    return JSON.parse(raw)
+  } catch {
+    return {}
+  }
+}
+
+/**
+ * Perception connection: env wins, then ~/.robrain/config.json (written by
+ * `robrain up` / `robrain install`), then localhost default.
+ */
+export function loadPerception() {
+  let url = process.env.PERCEPTION_URL?.trim() || ''
+  let key = process.env.PERCEPTION_API_KEY?.trim() || ''
+  if (!url || !key) {
+    try {
+      const cfg = JSON.parse(readFileSync(join(homedir(), '.robrain', 'config.json'), 'utf8'))
+      if (!url && typeof cfg.perceptionUrl === 'string') url = cfg.perceptionUrl.trim()
+      if (!key && typeof cfg.perceptionKey === 'string') key = cfg.perceptionKey.trim()
+    } catch {
+      // no config yet — fall through to defaults
+    }
+  }
+  return { url: url || 'http://localhost:3001', key }
+}
+
+/**
+ * Same derivation as the CLI (packages/cli/src/lib/project.ts): prefer the
+ * project_id init-project wrote into CLAUDE.md / AGENTS.md / the Cursor rule,
+ * else a stable hash of the working directory.
+ */
+export function resolveProjectId(cwd) {
+  for (const rel of ['CLAUDE.md', 'AGENTS.md', join('.cursor', 'rules', 'robrain.mdc')]) {
+    const p = join(cwd, rel)
+    try {
+      if (!existsSync(p)) continue
+      const match = readFileSync(p, 'utf8').match(/project_id="([^"]+)"/)
+      if (match?.[1]) return match[1].trim()
+    } catch {
+      // unreadable file — try the next candidate
+    }
+  }
+  return createHash('sha256').update(cwd).digest('hex').slice(0, 12)
+}
+
+/** fetch with a hard timeout; returns null instead of throwing. */
+export async function perceptionFetch(path, { url, key }, init = {}, timeoutMs = 2500) {
+  try {
+    const res = await fetch(`${url}${path}`, {
+      ...init,
+      headers: {
+        'Content-Type': 'application/json',
+        ...(key ? { Authorization: `Bearer ${key}` } : {}),
+        ...(init.headers ?? {}),
+      },
+      signal: AbortSignal.timeout(timeoutMs),
+    })
+    if (!res.ok) return null
+    return await res.json()
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Extract the trailing turn from a Claude Code transcript (JSONL): the last
+ * user text message and every assistant text block after it, plus file paths
+ * touched by Edit/Write/NotebookEdit tool calls in that span.
+ */
+export function extractLastTurn(transcriptPath) {
+  let lines
+  try {
+    lines = readFileSync(transcriptPath, 'utf8').split('\n').filter(Boolean)
+  } catch {
+    return null
+  }
+
+  let lastUserIdx = -1
+  const entries = []
+  for (const line of lines) {
+    let e
+    try {
+      e = JSON.parse(line)
+    } catch {
+      continue
+    }
+    entries.push(e)
+  }
+
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const e = entries[i]
+    if (e.type === 'user' && !e.isMeta && typeof textOf(e.message?.content) === 'string' && textOf(e.message.content).trim()) {
+      // Skip tool_result-only user entries (tool outputs come back as user role)
+      if (hasOnlyToolResults(e.message?.content)) continue
+      lastUserIdx = i
+      break
+    }
+  }
+  if (lastUserIdx === -1) return null
+
+  const userMessage = textOf(entries[lastUserIdx].message?.content) ?? ''
+  const replyParts = []
+  const filesTouched = new Set()
+
+  for (let i = lastUserIdx + 1; i < entries.length; i++) {
+    const e = entries[i]
+    if (e.type !== 'assistant') continue
+    const content = e.message?.content
+    if (!Array.isArray(content)) continue
+    for (const block of content) {
+      if (block.type === 'text' && block.text?.trim()) replyParts.push(block.text)
+      if (block.type === 'tool_use') {
+        const fp = block.input?.file_path ?? block.input?.notebook_path
+        if (typeof fp === 'string' && fp) filesTouched.add(fp)
+      }
+    }
+  }
+
+  if (!userMessage.trim() || replyParts.length === 0) return null
+
+  // Sequence: number of user-authored messages up to and including this one —
+  // stable across re-reads of the same transcript.
+  let sequence = 0
+  for (let i = 0; i <= lastUserIdx; i++) {
+    const e = entries[i]
+    if (e.type === 'user' && !e.isMeta && !hasOnlyToolResults(e.message?.content) && textOf(e.message?.content)?.trim()) sequence++
+  }
+
+  return {
+    userMessage,
+    claudeReply: replyParts.join('\n\n'),
+    filesTouched: [...filesTouched].slice(0, 50),
+    sequence: Math.max(1, sequence),
+  }
+}
+
+function textOf(content) {
+  if (typeof content === 'string') return content
+  if (Array.isArray(content)) {
+    return content.filter(b => b.type === 'text').map(b => b.text ?? '').join('\n')
+  }
+  return null
+}
+
+function hasOnlyToolResults(content) {
+  return Array.isArray(content) && content.length > 0 && content.every(b => b.type === 'tool_result')
+}
+
+// ── Session-scoped warning state ──────────────────────────────
+// The same veto re-injected on every on-topic prompt is context spend for
+// zero new information — Control must never cost more context than it saves.
+
+const STATE_DIR = join(homedir(), '.robrain', 'state')
+
+function warnedFile(sessionId) {
+  const safe = sessionId.replace(/[^A-Za-z0-9._-]/g, '_').slice(0, 120)
+  return join(STATE_DIR, `cc-warned-${safe}.json`)
+}
+
+/** Decision ids already warned about in this session. */
+export function loadWarnedIds(sessionId) {
+  if (!sessionId) return new Set()
+  try {
+    const ids = JSON.parse(readFileSync(warnedFile(sessionId), 'utf8'))
+    return new Set(Array.isArray(ids) ? ids : [])
+  } catch {
+    return new Set()
+  }
+}
+
+export function recordWarnedIds(sessionId, ids) {
+  if (!sessionId || ids.length === 0) return
+  try {
+    mkdirSync(STATE_DIR, { recursive: true })
+    const merged = [...new Set([...loadWarnedIds(sessionId), ...ids])].slice(-200)
+    writeFileSync(warnedFile(sessionId), JSON.stringify(merged))
+    cleanupStateDir()
+  } catch {
+    // fail-open — a broken state file must never block the session
+  }
+}
+
+/** Best-effort hygiene: drop state files older than 7 days. */
+function cleanupStateDir() {
+  try {
+    const cutoff = Date.now() - 7 * 24 * 60 * 60 * 1000
+    for (const f of readdirSync(STATE_DIR)) {
+      const p = join(STATE_DIR, f)
+      try {
+        if (statSync(p).mtimeMs < cutoff) unlinkSync(p)
+      } catch {
+        // race or permissions — skip
+      }
+    }
+  } catch {
+    // dir unreadable — skip
+  }
+}
+
+// ── Per-session prompt stash ──────────────────────────────────
+// Written by the UserPromptSubmit hook, read by stop hooks that cannot rely
+// on a parseable transcript (Codex ships last_assistant_message on Stop stdin
+// but its transcript format is not a contract we own). Pairing the stashed
+// prompt with that message gives deterministic capture with zero transcript
+// assumptions.
+
+function stashFile(sessionId) {
+  const safe = sessionId.replace(/[^A-Za-z0-9._-]/g, '_').slice(0, 120)
+  return join(STATE_DIR, `stash-${safe}.json`)
+}
+
+export function stashPrompt(sessionId, prompt) {
+  if (!sessionId || !prompt) return
+  try {
+    mkdirSync(STATE_DIR, { recursive: true })
+    const prev = loadPromptStash(sessionId)
+    writeFileSync(stashFile(sessionId), JSON.stringify({
+      prompt: prompt.slice(0, 60_000),
+      sequence: (prev?.sequence ?? 0) + 1,
+    }))
+  } catch {
+    // fail-open
+  }
+}
+
+export function loadPromptStash(sessionId) {
+  if (!sessionId) return null
+  try {
+    const s = JSON.parse(readFileSync(stashFile(sessionId), 'utf8'))
+    return typeof s?.prompt === 'string' ? s : null
+  } catch {
+    return null
+  }
+}
+
+/** Emit hook JSON output (context injection) and exit 0. */
+export function emitContext(hookEventName, additionalContext) {
+  if (additionalContext) {
+    process.stdout.write(JSON.stringify({
+      hookSpecificOutput: { hookEventName, additionalContext },
+    }))
+  }
+  process.exit(0)
+}
+
+/** Silent success — hooks must never fail the session. */
+export function exitSilently() {
+  process.exit(0)
+}

package/vendor/codex-hooks/session-start.mjs

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+// SessionStart hook — inject the always-on project summary (top decisions with
+// their rejected alternatives) at the start of every Claude Code session.
+// Deterministic replacement for the model remembering to call sensing_start_session.
+
+import {
+  readStdin, parseHookInput, loadPerception, resolveProjectId,
+  perceptionFetch, emitContext, exitSilently,
+} from './lib.mjs'
+
+const input = parseHookInput(await readStdin())
+const cwd = input.cwd ?? process.cwd()
+const perception = loadPerception()
+const projectId = resolveProjectId(cwd)
+
+const summary = await perceptionFetch(`/projects/${projectId}/summary`, perception, {}, 3000)
+const text = summary?.summary ?? summary?.always_on_summary
+if (!text || typeof text !== 'string' || !text.trim()) exitSilently()
+
+emitContext(
+  'SessionStart',
+  [
+    '## RoBrain project memory (always-on summary)',
+    'Prior decisions for this project, including rejected alternatives. Respect the rejections —',
+    'if a task invites a previously rejected approach, surface the rejection instead of re-proposing it.',
+    '',
+    text.trim(),
+  ].join('\n'),
+)

package/vendor/codex-hooks/stop.mjs

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+// Codex Stop hook — deterministic turn capture for Codex CLI / IDE.
+//
+// Codex's Stop stdin carries `last_assistant_message` directly, and the
+// UserPromptSubmit hook stashed the user prompt — so capture needs ZERO
+// assumptions about Codex's transcript format (which is not a contract we
+// own). The transcript, when it happens to parse as Claude-style JSONL, only
+// enriches the signal with files touched.
+//
+// Ships the turn to Perception POST /signals with needs_classification=true;
+// extraction, the confidence gate, and near-duplicate dedup run server-side —
+// including dedup against turns captured via the Sensing MCP protocol, so
+// running both double-captures nothing.
+
+import {
+  readStdin, parseHookInput, loadPerception, resolveProjectId,
+  perceptionFetch, extractLastTurn, loadPromptStash, exitSilently,
+} from './lib.mjs'
+
+const input = parseHookInput(await readStdin())
+
+// stop_hook_active guards re-entry when a stop hook itself continues the turn.
+if (input.stop_hook_active) exitSilently()
+
+const sessionId = typeof input.session_id === 'string' ? input.session_id : ''
+const cwd = input.cwd ?? process.cwd()
+if (!sessionId) exitSilently()
+
+// Reply: stdin first; transcript parse as fallback.
+let reply = typeof input.last_assistant_message === 'string' ? input.last_assistant_message : ''
+
+// Prompt: the UserPromptSubmit stash is authoritative; transcript is fallback.
+const stash = loadPromptStash(sessionId)
+let userMessage = stash?.prompt ?? ''
+let sequence = stash?.sequence ?? 1
+let filesTouched = []
+
+if ((!userMessage || !reply) && input.transcript_path) {
+  const turn = extractLastTurn(input.transcript_path)
+  if (turn) {
+    if (!userMessage) { userMessage = turn.userMessage; sequence = turn.sequence }
+    if (!reply) reply = turn.claudeReply
+    filesTouched = turn.filesTouched
+  }
+} else if (input.transcript_path) {
+  // Both present — transcript only enriches with files touched, best-effort.
+  const turn = extractLastTurn(input.transcript_path)
+  if (turn) filesTouched = turn.filesTouched
+}
+
+if (!userMessage.trim() || !reply.trim()) exitSilently()
+
+const perception = loadPerception()
+const projectId = resolveProjectId(cwd)
+
+await perceptionFetch('/signals', perception, {
+  method: 'POST',
+  headers: { 'X-Project-Id': projectId },
+  body: JSON.stringify({
+    signal: {
+      turn: {
+        session_id:    `codex-${sessionId}`.slice(0, 200),
+        sequence,
+        user_message:  userMessage.slice(0, 60_000),
+        claude_reply:  reply.slice(0, 60_000),
+        files_touched: filesTouched,
+        timestamp:     new Date().toISOString(),
+      },
+      decision_type:        'unclassified',
+      confidence:           0,
+      files_affected:       filesTouched,
+      scope:                'team',
+      needs_classification: true,
+    },
+  }),
+}, 8000)
+
+exitSilently()

package/vendor/codex-hooks/user-prompt-submit.mjs

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+// UserPromptSubmit hook — pre-task veto injection, two tiers:
+//  1. Deterministic: POST /veto-scan — does the prompt literally name an
+//     option an active decision rejected? Zero embeddings, zero LLM, fires
+//     for ANY prompt length. An exact mention warns at confidence 1.0.
+//  2. Semantic: GET /decisions?query= for prompts long enough to embed.
+//     Gated on SIMILARITY, not planning_score — planning_score blends in
+//     recency decay, and a rejection must not fade from warnings just
+//     because it is old.
+// Warnings already shown this session are not repeated (state file) —
+// injected context must never cost more than it saves.
+
+import {
+  readStdin, parseHookInput, loadPerception, resolveProjectId,
+  perceptionFetch, emitContext, exitSilently, loadWarnedIds, recordWarnedIds,
+  stashPrompt,
+} from './lib.mjs'
+
+const input = parseHookInput(await readStdin())
+const prompt = (input.prompt ?? '').trim()
+
+// Skip: slash commands and empty prompts. The deterministic tier is cheap
+// enough to run even on short prompts ("use Pinecone now" must warn).
+if (!prompt || prompt.startsWith('/')) exitSilently()
+
+const cwd = input.cwd ?? process.cwd()
+const sessionId = typeof input.session_id === 'string' ? input.session_id : ''
+
+// Stash the prompt for stop-hook capture on clients whose transcript format
+// we do not parse (Codex pairs this with last_assistant_message).
+stashPrompt(sessionId, prompt)
+const perception = loadPerception()
+const projectId = resolveProjectId(cwd)
+
+// Tier 1 — deterministic rejected-option scan.
+const scan = await perceptionFetch('/veto-scan', perception, {
+  method: 'POST',
+  body: JSON.stringify({ project_id: projectId, text: prompt.slice(0, 2000) }),
+}, 1500)
+const exact = (Array.isArray(scan?.matches) ? scan.matches : [])
+  .map(m => ({ ...m, exact: true }))
+
+// Tier 2 — semantic search only for prompts worth an embedding round-trip
+// (greetings, "yes", … skip it).
+const MIN_SIMILARITY = 0.45
+let semantic = []
+if (prompt.length >= 24) {
+  const params = new URLSearchParams({
+    project_id: projectId,
+    query: prompt.slice(0, 2000),
+    limit: '8',
+  })
+  const data = await perceptionFetch(`/decisions?${params}`, perception, {}, 2500)
+  const decisions = Array.isArray(data) ? data : data?.decisions
+  if (Array.isArray(decisions)) {
+    semantic = decisions
+      .filter(d => Array.isArray(d.rejected) && d.rejected.length > 0)
+      .filter(d => typeof d.similarity !== 'number' || d.similarity >= MIN_SIMILARITY)
+      .sort((a, b) => (b.similarity ?? 0) - (a.similarity ?? 0))
+  }
+}
+
+// Merge: exact matches first (exempt from the similarity gate), then
+// semantic; skip anything already warned in this session.
+const warned = loadWarnedIds(sessionId)
+const seen = new Set()
+const vetoes = []
+for (const d of [...exact, ...semantic]) {
+  if (!d.id || seen.has(d.id) || warned.has(d.id)) continue
+  seen.add(d.id)
+  vetoes.push(d)
+  if (vetoes.length === 3) break
+}
+
+if (vetoes.length === 0) exitSilently()
+
+const lines = vetoes.map(d => {
+  const rej = d.rejected
+    .slice(0, 2)
+    .map(r => `**${r.option}** (${r.reason})`)
+    .join('; ')
+  const tag = d.exact ? ' *(exact match on rejected option)*' : ''
+  return `- ${d.decision}${tag}\n  Rejected: ${rej}`
+})
+
+recordWarnedIds(sessionId, vetoes.map(d => d.id))
+
+emitContext(
+  'UserPromptSubmit',
+  [
+    '⚠ RoBrain — this task touches decisions with previously REJECTED approaches:',
+    ...lines,
+    'Do not re-propose a rejected option without flagging the prior rejection and why circumstances changed.',
+  ].join('\n'),
+)

package/vendor/sensing-mcp/dist/index.js

@@ -6911,6 +6911,30 @@ var require_redact = __commonJS({
   }
 });
 
+// ../shared/dist/veto-match.js
+var require_veto_match = __commonJS({
+  "../shared/dist/veto-match.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.proposalMatchesRejectedOption = proposalMatchesRejectedOption;
+    function proposalMatchesRejectedOption(proposalText, rejected) {
+      if (!rejected?.length)
+        return null;
+      for (const r of rejected) {
+        const option = r.option.trim();
+        if (option.length < 3)
+          continue;
+        const escaped = option.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const lead = /^[A-Za-z0-9_]/.test(option) ? "\\b" : "";
+        const trail = /[A-Za-z0-9_]$/.test(option) ? "\\b" : "";
+        if (new RegExp(`${lead}${escaped}${trail}`, "i").test(proposalText))
+          return r;
+      }
+      return null;
+    }
+  }
+});
+
 // ../shared/dist/extract-decision.js
 var require_extract_decision = __commonJS({
   "../shared/dist/extract-decision.js"(exports) {
@@ -7045,6 +7069,7 @@ var require_dist = __commonJS({
     __exportStar(require_llm(), exports);
     __exportStar(require_embeddings(), exports);
     __exportStar(require_redact(), exports);
+    __exportStar(require_veto_match(), exports);
     __exportStar(require_extract_decision(), exports);
     __exportStar(require_db(), exports);
   }
@@ -23037,7 +23062,7 @@ function resolveSessionId(raw) {
 function buildServer() {
   const server = new McpServer({
     name: "sensing-mcp",
-    version: "2.3.7"
+    version: "2.3.9"
   });
   server.tool(
     "sensing_start_session",

package/vendor/sensing-mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robrain/sensing-mcp",
-  "version": "2.3.7",
+  "version": "2.3.9",
   "private": true,
   "type": "module",
   "main": "./dist/index.js"