robrain 2.4.11 → 2.6.0

package/vendor/sensing-mcp/package.json

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

package/vendor/synthesis/dist/index.js

@@ -11853,22 +11853,26 @@ var require_embeddings = __commonJS({
       }
     };
     exports.EmbeddingProviderError = EmbeddingProviderError;
-    async function embed(text, config2, signal) {
-      let vec;
+    async function embed(text, config2, signal, onUsage) {
+      let out;
       switch (config2.provider) {
         case "openai":
-          vec = await embedOpenAI(text, config2, signal);
+          out = await embedOpenAI(text, config2, signal);
           break;
         case "voyage":
-          vec = await embedVoyage(text, config2, signal);
+          out = await embedVoyage(text, config2, signal);
           break;
         case "cohere":
-          vec = await embedCohere(text, config2, signal);
+          out = await embedCohere(text, config2, signal);
           break;
         default:
           throw new EmbeddingProviderError(config2.provider, `Unknown embedding provider: ${config2.provider}`);
       }
-      return padToLength(vec, exports.EMBEDDING_TARGET_DIMS);
+      onUsage?.({ inputTokens: out.inputTokens });
+      return padToLength(out.vector, exports.EMBEDDING_TARGET_DIMS);
+    }
+    function tokenCount(x2) {
+      return typeof x2 === "number" && Number.isFinite(x2) && x2 >= 0 ? Math.round(x2) : null;
     }
     async function embedOpenAI(text, config2, signal) {
       const baseUrl = config2.openaiBaseUrl.replace(/\/+$/, "");
@@ -11888,7 +11892,10 @@ var require_embeddings = __commonJS({
         })
       }, "openai", config2, signal);
       const data = await res.json();
-      return ensureEmbedding("openai", data.data?.[0]?.embedding);
+      return {
+        vector: ensureEmbedding("openai", data.data?.[0]?.embedding),
+        inputTokens: tokenCount(data.usage?.prompt_tokens) ?? tokenCount(data.usage?.total_tokens)
+      };
     }
     async function embedVoyage(text, config2, signal) {
       if (!config2.voyageApiKey) {
@@ -11906,7 +11913,10 @@ var require_embeddings = __commonJS({
         })
       }, "voyage", config2, signal);
       const data = await res.json();
-      return ensureEmbedding("voyage", data.data?.[0]?.embedding);
+      return {
+        vector: ensureEmbedding("voyage", data.data?.[0]?.embedding),
+        inputTokens: tokenCount(data.usage?.total_tokens)
+      };
     }
     async function embedCohere(text, config2, signal) {
       if (!config2.cohereApiKey) {
@@ -11926,7 +11936,10 @@ var require_embeddings = __commonJS({
         })
       }, "cohere", config2, signal);
       const data = await res.json();
-      return ensureEmbedding("cohere", data.embeddings?.float?.[0]);
+      return {
+        vector: ensureEmbedding("cohere", data.embeddings?.float?.[0]),
+        inputTokens: tokenCount(data.meta?.billed_units?.input_tokens)
+      };
     }
     async function fetchEmbedding(url, init, provider, config2, callerSignal) {
       let lastDetail = "";
@@ -12454,16 +12467,179 @@ var require_trust = __commonJS({
   }
 });
 
+// ../shared/dist/capture-settings.js
+var require_capture_settings = __commonJS({
+  "../shared/dist/capture-settings.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DEFAULT_CAPTURE_SETTINGS = exports.DEFAULT_CAPTURE_KIND = exports.CAPTURE_MODES = exports.CAPTURE_KIND_DESCRIPTION_MAX_CHARS = exports.CAPTURE_KIND_NAME_MAX_CHARS = exports.CAPTURE_KINDS_MAX = exports.CAPTURE_INSTRUCTIONS_MAX_CHARS = void 0;
+    exports.isDefaultCaptureSettings = isDefaultCaptureSettings;
+    exports.normalizeKindName = normalizeKindName;
+    exports.applyCaptureSettingsPatch = applyCaptureSettingsPatch;
+    exports.coerceCaptureSettings = coerceCaptureSettings;
+    exports.subjectTokens = subjectTokens;
+    exports.subjectsMatch = subjectsMatch;
+    exports.effectiveConfidenceMin = effectiveConfidenceMin;
+    exports.allowedKindNames = allowedKindNames;
+    exports.CAPTURE_INSTRUCTIONS_MAX_CHARS = 2e3;
+    exports.CAPTURE_KINDS_MAX = 8;
+    exports.CAPTURE_KIND_NAME_MAX_CHARS = 32;
+    exports.CAPTURE_KIND_DESCRIPTION_MAX_CHARS = 300;
+    exports.CAPTURE_MODES = ["strict", "broad"];
+    exports.DEFAULT_CAPTURE_KIND = "decision";
+    exports.DEFAULT_CAPTURE_SETTINGS = {
+      instructions: null,
+      mode: "strict",
+      confidence_min: null,
+      kinds: []
+    };
+    function isDefaultCaptureSettings(s2) {
+      return s2.instructions === null && s2.mode === "strict" && s2.confidence_min === null && s2.kinds.length === 0;
+    }
+    function normalizeKindName(name) {
+      return name.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "");
+    }
+    function applyCaptureSettingsPatch(current, patch) {
+      const errors = [];
+      const next = { ...current, kinds: [...current.kinds] };
+      if (patch.instructions !== void 0) {
+        if (patch.instructions === null || patch.instructions.trim() === "") {
+          next.instructions = null;
+        } else if (typeof patch.instructions !== "string") {
+          errors.push("instructions must be text");
+        } else if (patch.instructions.length > exports.CAPTURE_INSTRUCTIONS_MAX_CHARS) {
+          errors.push(`instructions must be at most ${exports.CAPTURE_INSTRUCTIONS_MAX_CHARS} characters (got ${patch.instructions.length})`);
+        } else {
+          next.instructions = patch.instructions.trim();
+        }
+      }
+      if (patch.mode !== void 0) {
+        const mode = String(patch.mode).trim().toLowerCase();
+        if (exports.CAPTURE_MODES.includes(mode)) {
+          next.mode = mode;
+        } else {
+          errors.push(`mode must be one of: ${exports.CAPTURE_MODES.join(", ")}`);
+        }
+      }
+      if (patch.confidence_min !== void 0) {
+        if (patch.confidence_min === null) {
+          next.confidence_min = null;
+        } else if (typeof patch.confidence_min !== "number" || !Number.isFinite(patch.confidence_min)) {
+          errors.push("confidence_min must be a number between 0 and 1");
+        } else if (patch.confidence_min < 0 || patch.confidence_min > 1) {
+          errors.push("confidence_min must be between 0 and 1");
+        } else {
+          next.confidence_min = Math.round(patch.confidence_min * 100) / 100;
+        }
+      }
+      if (patch.kinds !== void 0) {
+        if (patch.kinds === null) {
+          next.kinds = [];
+        } else if (!Array.isArray(patch.kinds)) {
+          errors.push("kinds must be a list");
+        } else if (patch.kinds.length > exports.CAPTURE_KINDS_MAX) {
+          errors.push(`at most ${exports.CAPTURE_KINDS_MAX} kinds`);
+        } else {
+          const seen = /* @__PURE__ */ new Set();
+          const kinds = [];
+          for (const raw of patch.kinds) {
+            const name = typeof raw?.name === "string" ? normalizeKindName(raw.name) : "";
+            const description = typeof raw?.description === "string" ? raw.description.trim() : "";
+            if (!name) {
+              errors.push("each kind needs a name (letters, digits, - or _)");
+              continue;
+            }
+            if (name.length > exports.CAPTURE_KIND_NAME_MAX_CHARS) {
+              errors.push(`kind name "${name}" is longer than ${exports.CAPTURE_KIND_NAME_MAX_CHARS} characters`);
+              continue;
+            }
+            if (name === exports.DEFAULT_CAPTURE_KIND) {
+              errors.push(`"${exports.DEFAULT_CAPTURE_KIND}" is the built-in kind and cannot be redefined`);
+              continue;
+            }
+            if (!description) {
+              errors.push(`kind "${name}" needs a description so the model knows what to store`);
+              continue;
+            }
+            if (description.length > exports.CAPTURE_KIND_DESCRIPTION_MAX_CHARS) {
+              errors.push(`description for kind "${name}" is longer than ${exports.CAPTURE_KIND_DESCRIPTION_MAX_CHARS} characters`);
+              continue;
+            }
+            if (seen.has(name)) {
+              errors.push(`kind "${name}" is listed twice`);
+              continue;
+            }
+            seen.add(name);
+            kinds.push({ name, description });
+          }
+          next.kinds = kinds;
+        }
+      }
+      return errors.length ? { ok: false, errors } : { ok: true, settings: next };
+    }
+    function coerceCaptureSettings(raw) {
+      if (!raw || typeof raw !== "object")
+        return { ...exports.DEFAULT_CAPTURE_SETTINGS };
+      const r2 = raw;
+      const result = applyCaptureSettingsPatch(exports.DEFAULT_CAPTURE_SETTINGS, {
+        instructions: typeof r2.instructions === "string" ? r2.instructions : null,
+        mode: typeof r2.mode === "string" ? r2.mode : "strict",
+        confidence_min: typeof r2.confidence_min === "number" ? r2.confidence_min : null,
+        kinds: Array.isArray(r2.kinds) ? r2.kinds : []
+      });
+      if (result.ok)
+        return result.settings;
+      const safe = { ...exports.DEFAULT_CAPTURE_SETTINGS };
+      const instructions = applyCaptureSettingsPatch(safe, { instructions: typeof r2.instructions === "string" ? r2.instructions : null });
+      if (instructions.ok)
+        safe.instructions = instructions.settings.instructions;
+      const mode = applyCaptureSettingsPatch(safe, { mode: typeof r2.mode === "string" ? r2.mode : "strict" });
+      if (mode.ok)
+        safe.mode = mode.settings.mode;
+      const conf = applyCaptureSettingsPatch(safe, { confidence_min: typeof r2.confidence_min === "number" ? r2.confidence_min : null });
+      if (conf.ok)
+        safe.confidence_min = conf.settings.confidence_min;
+      const kinds = applyCaptureSettingsPatch(safe, { kinds: Array.isArray(r2.kinds) ? r2.kinds : [] });
+      if (kinds.ok)
+        safe.kinds = kinds.settings.kinds;
+      return safe;
+    }
+    var SUBJECT_STOPWORDS = /* @__PURE__ */ new Set(["the", "a", "an", "of", "for", "on", "in", "at", "to", "and", "this", "that", "our", "my", "its", "last", "latest", "current"]);
+    function subjectTokens(subject) {
+      return subject.toLowerCase().replace(/[^a-z0-9\s_-]+/g, " ").split(/[\s_-]+/).filter((t2) => t2.length > 1 && !SUBJECT_STOPWORDS.has(t2));
+    }
+    function subjectsMatch(a2, b2) {
+      const ta = new Set(subjectTokens(a2));
+      const tb = new Set(subjectTokens(b2));
+      if (ta.size === 0 || tb.size === 0)
+        return false;
+      const [small, large] = ta.size <= tb.size ? [ta, tb] : [tb, ta];
+      for (const t2 of small)
+        if (!large.has(t2))
+          return false;
+      return true;
+    }
+    function effectiveConfidenceMin(settings, stock) {
+      return settings?.confidence_min ?? stock;
+    }
+    function allowedKindNames(settings) {
+      return [exports.DEFAULT_CAPTURE_KIND, ...(settings?.kinds ?? []).map((k2) => k2.name)];
+    }
+  }
+});
+
 // ../shared/dist/extract-decision.js
 var require_extract_decision = __commonJS({
   "../shared/dist/extract-decision.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.LlmKeyMissingError = exports.SELF_HOSTED_USER_RULE_OVERRIDE = exports.DECISION_EXTRACTION_SYSTEM_PROMPT = void 0;
+    exports.buildCaptureRules = buildCaptureRules;
     exports.stripMarkdownJsonFence = stripMarkdownJsonFence2;
     exports.parseExtractedDecision = parseExtractedDecision;
     exports.extractDecisionLlm = extractDecisionLlm;
     var llm_js_1 = require_llm();
+    var capture_settings_js_1 = require_capture_settings();
     exports.DECISION_EXTRACTION_SYSTEM_PROMPT = `You extract technical decisions from software development conversations.
 
 A decision includes ANY of the following (not only formal deliberation):
@@ -12489,6 +12665,23 @@ Fields:
 Output ONLY valid JSON. If no decision: {"decision": null, "rationale": null, "rejected": [], "confidence": 0}.
 Never add explanation outside the JSON.
 Schema: {"decision": string|null, "rationale": string|null, "rejected": [{"option": string, "reason": string}], "confidence": number}`;
+    function buildCaptureRules(capture) {
+      if (!capture)
+        return "";
+      const sections = [];
+      if (capture.kinds.length > 0) {
+        const kindLines = capture.kinds.map((k2) => `- "${k2.name}": ${k2.description}`).join("\n");
+        sections.push(`Besides decisions, this project also stores these kinds of memory:
+${kindLines}
+The rules above about what is NOT a decision apply only to kind "${capture_settings_js_1.DEFAULT_CAPTURE_KIND}". A turn that contains an entry of one of the listed kinds must be returned even though it contains no decision and nothing durable was committed: set "kind" to that kind's name, put the entry in "entry" as one short factual sentence (what happened, when, with what result), set "subject" to a short stable label for the thing it is about (max 6 words, the same words each time so a newer entry about the same subject replaces the older one), set "confidence" to how sure you are that the turn contains such an entry, and leave "decision" null. When the turn contains a decision, return it as usual with "kind": "${capture_settings_js_1.DEFAULT_CAPTURE_KIND}", "entry": null and "subject": null. Never invent a kind that is not listed.
+Schema: {"decision": string|null, "rationale": string|null, "rejected": [{"option": string, "reason": string}], "confidence": number, "kind": string, "entry": string|null, "subject": string|null}`);
+      }
+      if (capture.instructions) {
+        sections.push(`Project instructions for what to store (they refine the rules above; the output must stay valid JSON in the schema given):
+${capture.instructions}`);
+      }
+      return sections.join("\n\n");
+    }
     exports.SELF_HOSTED_USER_RULE_OVERRIDE = `User-stated rule wins:
 - A durable rule is a standing instruction for future work in this repo or team (e.g. "from now on", "always", "never", "we no longer"). An instruction scoped to the current task, file, or step (e.g. "don't use that file", "stop logging here", "don't add tests for this one") is not durable; apply the rules above to it.
 - If the user states a durable rule in this turn, extract that rule even when the assistant refuses it, cites an older rule, or says it will not follow the new one. In that case do not return null, and do not extract the older rule the assistant restates.`;
@@ -12503,24 +12696,28 @@ Schema: {"decision": string|null, "rationale": string|null, "rejected": [{"optio
     function stripMarkdownJsonFence2(raw) {
       return raw.trim().replace(/^```[a-z]*\s*/i, "").replace(/\s*```\s*$/, "").trim();
     }
-    function parseExtractedDecision(rawText) {
+    function parseExtractedDecision(rawText, allowedKinds = [capture_settings_js_1.DEFAULT_CAPTURE_KIND]) {
       const raw = JSON.parse(stripMarkdownJsonFence2(rawText));
       const rejected = Array.isArray(raw.rejected) ? raw.rejected.filter((x2) => x2 !== null && typeof x2 === "object" && typeof x2.option === "string" && typeof x2.reason === "string") : [];
       const confidence = typeof raw.confidence === "number" && Number.isFinite(raw.confidence) ? raw.confidence : 0;
+      const requestedKind = typeof raw.kind === "string" ? (0, capture_settings_js_1.normalizeKindName)(raw.kind) : capture_settings_js_1.DEFAULT_CAPTURE_KIND;
+      const kind2 = allowedKinds.includes(requestedKind) ? requestedKind : capture_settings_js_1.DEFAULT_CAPTURE_KIND;
+      const subject = kind2 !== capture_settings_js_1.DEFAULT_CAPTURE_KIND && typeof raw.subject === "string" && raw.subject.trim() ? raw.subject.trim().slice(0, 120) : null;
+      const entry = kind2 !== capture_settings_js_1.DEFAULT_CAPTURE_KIND && typeof raw.entry === "string" && raw.entry.trim() ? raw.entry.trim() : null;
       return {
-        decision: typeof raw.decision === "string" ? raw.decision : null,
+        decision: entry ?? (typeof raw.decision === "string" ? raw.decision : null),
         rationale: typeof raw.rationale === "string" ? raw.rationale : null,
         rejected,
-        confidence
+        confidence,
+        kind: kind2,
+        subject
       };
     }
     async function extractDecisionLlm(userMessage, claudeReply, cfg) {
       const userPrompt = `Session turn:
 User: ${userMessage}
 Claude: ${claudeReply}`;
-      const systemPrompt = cfg.extraSystemRules ? `${exports.DECISION_EXTRACTION_SYSTEM_PROMPT}
-
-${cfg.extraSystemRules}` : exports.DECISION_EXTRACTION_SYSTEM_PROMPT;
+      const systemPrompt = [exports.DECISION_EXTRACTION_SYSTEM_PROMPT, cfg.extraSystemRules, buildCaptureRules(cfg.capture)].filter((section) => Boolean(section)).join("\n\n");
       let rawText;
       if (cfg.provider === "openai") {
         const baseUrl = cfg.openaiBaseUrl ?? (0, llm_js_1.resolveOpenAiBaseUrl)();
@@ -12552,7 +12749,108 @@ ${cfg.extraSystemRules}` : exports.DECISION_EXTRACTION_SYSTEM_PROMPT;
           temperature: 0
         });
       }
-      return parseExtractedDecision(rawText);
+      return parseExtractedDecision(rawText, (0, capture_settings_js_1.allowedKindNames)(cfg.capture));
+    }
+  }
+});
+
+// ../shared/dist/capture-gate.js
+var require_capture_gate = __commonJS({
+  "../shared/dist/capture-gate.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.BROAD_MODE_MIN_USER_CHARS = exports.DECISION_KEYWORDS = void 0;
+    exports.captureGate = captureGate;
+    exports.DECISION_KEYWORDS = [
+      "decided",
+      "decision",
+      "going with",
+      "we'll use",
+      "let's use",
+      "instead of",
+      "switched to",
+      "switching to",
+      "rejected",
+      "won't use",
+      "we tried",
+      "too slow",
+      "doesn't work",
+      "went with",
+      "chosen",
+      "settled on",
+      "ruling out",
+      "dropping",
+      "replacing",
+      // Casual commitments / conventions (often no spelled-out alternatives)
+      "standardize",
+      "standardise",
+      "standardizing",
+      "moving to ",
+      "migrate to",
+      "migrate from",
+      "defaults to",
+      "default to",
+      "stick with",
+      "locking in",
+      "lock in"
+    ];
+    var AFFIRMATION_PATTERNS = [
+      /\b(yes|yep|yeah|yup|sure)\b/i,
+      /\b(agreed|agree|approved?)\b/i,
+      /\blet['’]s\s+(do|go|use|try|ship|stick|adopt|switch|move|migrate)\b/i,
+      /\b(go|going)\s+with\b/i,
+      /\bsounds\s+good\b/i,
+      /\bdo\s+it\b/i,
+      /\bship\s+it\b/i
+    ];
+    var IMPLICIT_ACTION_PATTERNS = [
+      /import .+ from ['"][^'"]+['"]/,
+      /require\(['"][^'"]+['"]\)/,
+      /npm install|pnpm add|yarn add/
+    ];
+    var IMPLICIT_USER_COMMITMENT_PATTERNS = [
+      /\blet['’]s\s+(standardize|standardise|use|go with|stick with|adopt)\b/i,
+      /\b(from now on|going forward)\b/i,
+      /\b(always|never)\s+(use|write|add|call|prefer|put|name|run|import|suggest|commit|push|merge|install|mock)\b/i,
+      /\b(don['’]t|do not|stop|no longer)\s+(use|using|write|writing|add|adding|call|calling|suggest|suggesting|import|importing)\b/i
+    ];
+    exports.BROAD_MODE_MIN_USER_CHARS = 24;
+    function captureGate(turn, settings) {
+      const userText = turn.user_message.toLowerCase();
+      const assistantText = turn.claude_reply.toLowerCase();
+      const userAffirmed = AFFIRMATION_PATTERNS.some((p2) => p2.test(turn.user_message));
+      const keywordInUser = exports.DECISION_KEYWORDS.some((kw) => userText.includes(kw));
+      const keywordInAssistant = !keywordInUser && exports.DECISION_KEYWORDS.some((kw) => assistantText.includes(kw));
+      if (keywordInUser || keywordInAssistant && userAffirmed) {
+        return { reachesModel: true, reason: "keyword" };
+      }
+      const implicitHit = IMPLICIT_ACTION_PATTERNS.some((p2) => p2.test(`${turn.user_message} ${turn.claude_reply}`)) || IMPLICIT_USER_COMMITMENT_PATTERNS.some((p2) => p2.test(turn.user_message));
+      if (implicitHit)
+        return { reachesModel: true, reason: "implicit" };
+      if (settings?.mode === "broad" && turn.user_message.trim().length >= exports.BROAD_MODE_MIN_USER_CHARS) {
+        return { reachesModel: true, reason: "broad" };
+      }
+      return { reachesModel: false, reason: "none" };
+    }
+  }
+});
+
+// ../shared/dist/author-email.js
+var require_author_email = __commonJS({
+  "../shared/dist/author-email.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.AUTHOR_EMAIL_MAX_CHARS = void 0;
+    exports.normalizeAuthorEmail = normalizeAuthorEmail;
+    exports.AUTHOR_EMAIL_MAX_CHARS = 254;
+    var AUTHOR_EMAIL_RE = /^[a-z0-9._%+-]{1,64}@[a-z0-9-]+(\.[a-z0-9-]+)+$/;
+    function normalizeAuthorEmail(raw) {
+      if (typeof raw !== "string")
+        return null;
+      const email = raw.trim().toLowerCase();
+      if (!email || email.length > exports.AUTHOR_EMAIL_MAX_CHARS)
+        return null;
+      return AUTHOR_EMAIL_RE.test(email) ? email : null;
     }
   }
 });
@@ -12600,6 +12898,9 @@ var require_dist2 = __commonJS({
     __exportStar(require_veto_match(), exports);
     __exportStar(require_trust(), exports);
     __exportStar(require_extract_decision(), exports);
+    __exportStar(require_capture_settings(), exports);
+    __exportStar(require_capture_gate(), exports);
+    __exportStar(require_author_email(), exports);
     __exportStar(require_db(), exports);
   }
 });

package/vendor/synthesis/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robrain/synthesis",
-  "version": "2.4.11",
+  "version": "2.6.0",
   "private": true,
   "type": "module",
   "main": "./dist/index.js"