robrain 2.4.10 → 2.5.0

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

@@ -7190,16 +7190,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 = coerceCaptureSettings2;
+    exports.subjectTokens = subjectTokens;
+    exports.subjectsMatch = subjectsMatch;
+    exports.effectiveConfidenceMin = effectiveConfidenceMin2;
+    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(s) {
+      return s.instructions === null && s.mode === "strict" && s.confidence_min === null && s.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 coerceCaptureSettings2(raw) {
+      if (!raw || typeof raw !== "object")
+        return { ...exports.DEFAULT_CAPTURE_SETTINGS };
+      const r = raw;
+      const result = applyCaptureSettingsPatch(exports.DEFAULT_CAPTURE_SETTINGS, {
+        instructions: typeof r.instructions === "string" ? r.instructions : null,
+        mode: typeof r.mode === "string" ? r.mode : "strict",
+        confidence_min: typeof r.confidence_min === "number" ? r.confidence_min : null,
+        kinds: Array.isArray(r.kinds) ? r.kinds : []
+      });
+      if (result.ok)
+        return result.settings;
+      const safe = { ...exports.DEFAULT_CAPTURE_SETTINGS };
+      const instructions = applyCaptureSettingsPatch(safe, { instructions: typeof r.instructions === "string" ? r.instructions : null });
+      if (instructions.ok)
+        safe.instructions = instructions.settings.instructions;
+      const mode = applyCaptureSettingsPatch(safe, { mode: typeof r.mode === "string" ? r.mode : "strict" });
+      if (mode.ok)
+        safe.mode = mode.settings.mode;
+      const conf = applyCaptureSettingsPatch(safe, { confidence_min: typeof r.confidence_min === "number" ? r.confidence_min : null });
+      if (conf.ok)
+        safe.confidence_min = conf.settings.confidence_min;
+      const kinds = applyCaptureSettingsPatch(safe, { kinds: Array.isArray(r.kinds) ? r.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((t) => t.length > 1 && !SUBJECT_STOPWORDS.has(t));
+    }
+    function subjectsMatch(a, b) {
+      const ta = new Set(subjectTokens(a));
+      const tb = new Set(subjectTokens(b));
+      if (ta.size === 0 || tb.size === 0)
+        return false;
+      const [small, large] = ta.size <= tb.size ? [ta, tb] : [tb, ta];
+      for (const t of small)
+        if (!large.has(t))
+          return false;
+      return true;
+    }
+    function effectiveConfidenceMin2(settings, stock) {
+      return settings?.confidence_min ?? stock;
+    }
+    function allowedKindNames(settings) {
+      return [exports.DEFAULT_CAPTURE_KIND, ...(settings?.kinds ?? []).map((k) => k.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 = stripMarkdownJsonFence;
     exports.parseExtractedDecision = parseExtractedDecision;
     exports.extractDecisionLlm = extractDecisionLlm2;
     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):
@@ -7225,6 +7388,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((k) => `- "${k.name}": ${k.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.`;
@@ -7239,24 +7419,28 @@ Schema: {"decision": string|null, "rationale": string|null, "rejected": [{"optio
     function stripMarkdownJsonFence(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(stripMarkdownJsonFence(rawText));
       const rejected = Array.isArray(raw.rejected) ? raw.rejected.filter((x) => x !== null && typeof x === "object" && typeof x.option === "string" && typeof x.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 kind = allowedKinds.includes(requestedKind) ? requestedKind : capture_settings_js_1.DEFAULT_CAPTURE_KIND;
+      const subject = kind !== capture_settings_js_1.DEFAULT_CAPTURE_KIND && typeof raw.subject === "string" && raw.subject.trim() ? raw.subject.trim().slice(0, 120) : null;
+      const entry = kind !== 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,
+        subject
       };
     }
     async function extractDecisionLlm2(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)();
@@ -7288,7 +7472,88 @@ ${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 = captureGate2;
+    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 captureGate2(turn, settings) {
+      const userText = turn.user_message.toLowerCase();
+      const assistantText = turn.claude_reply.toLowerCase();
+      const userAffirmed = AFFIRMATION_PATTERNS.some((p) => p.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((p) => p.test(`${turn.user_message} ${turn.claude_reply}`)) || IMPLICIT_USER_COMMITMENT_PATTERNS.some((p) => p.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" };
     }
   }
 });
@@ -7336,6 +7601,8 @@ var require_dist = __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_db(), exports);
   }
 });
@@ -22798,6 +23065,9 @@ var init_config = __esm({
       perceptionApiUrl: (0, import_shared.normalizeLoopbackUrl)(process.env.PERCEPTION_API_URL ?? "http://127.0.0.1:3001"),
       perceptionApiKey: process.env.PERCEPTION_API_KEY ?? "",
       // ── Classifier thresholds (optional — tune after instrumenting) ─
+      // DECISION_CONFIDENCE_MIN is this machine's stock value; a project can
+      // override it for everyone with `robrain capture set --min-confidence`,
+      // which wins when set (same for Perception's own re-extraction).
       decisionConfidenceMin: Number(process.env.DECISION_CONFIDENCE_MIN ?? 0.6),
       decisionConfidenceHigh: Number(process.env.DECISION_CONFIDENCE_HIGH ?? 0.9),
       topicShiftThreshold: Number(process.env.TOPIC_SHIFT_THRESHOLD ?? 0.35),
@@ -22895,23 +23165,65 @@ var init_embeddings = __esm({
   }
 });
 
+// src/capture-settings.ts
+async function fetchCaptureSettings(projectId) {
+  if (!config2.perceptionApiUrl) return { ...import_shared4.DEFAULT_CAPTURE_SETTINGS };
+  try {
+    const res = await fetch(
+      `${config2.perceptionApiUrl}/projects/${encodeURIComponent(projectId)}/capture`,
+      {
+        headers: { Authorization: `Bearer ${config2.perceptionApiKey}` },
+        signal: AbortSignal.timeout(config2.fetchTimeoutMs)
+      }
+    );
+    if (!res.ok) {
+      if (res.status !== 404) {
+        console.error(`[Sensing] capture settings fetch failed for ${projectId}: HTTP ${res.status}`);
+      }
+      return { ...import_shared4.DEFAULT_CAPTURE_SETTINGS };
+    }
+    return (0, import_shared4.coerceCaptureSettings)(await res.json());
+  } catch (err) {
+    console.error("[Sensing] capture settings fetch error:", err);
+    return { ...import_shared4.DEFAULT_CAPTURE_SETTINGS };
+  }
+}
+async function getCaptureSettings(projectId) {
+  const hit = cache.get(projectId);
+  if (hit && Date.now() - hit.fetchedAt < CACHE_TTL_MS) return hit.settings;
+  const pending = inFlight.get(projectId);
+  if (pending) return pending;
+  const request = fetchCaptureSettings(projectId).then((settings) => {
+    cache.set(projectId, { settings, fetchedAt: Date.now() });
+    return settings;
+  }).finally(() => inFlight.delete(projectId));
+  inFlight.set(projectId, request);
+  return request;
+}
+var import_shared4, CACHE_TTL_MS, cache, inFlight;
+var init_capture_settings = __esm({
+  "src/capture-settings.ts"() {
+    "use strict";
+    import_shared4 = __toESM(require_dist(), 1);
+    init_config();
+    CACHE_TTL_MS = 5 * 60 * 1e3;
+    cache = /* @__PURE__ */ new Map();
+    inFlight = /* @__PURE__ */ new Map();
+  }
+});
+
 // src/classifiers/index.ts
 function getLastClassifierFailure() {
   return lastClassifierFailure;
 }
 async function classifyDecision(turn, projectId) {
-  const userText = turn.user_message.toLowerCase();
-  const assistantText = turn.claude_reply.toLowerCase();
-  const userAffirmed = AFFIRMATION_PATTERNS.some((p) => p.test(turn.user_message));
-  const keywordInUser = DECISION_KEYWORDS.some((kw) => userText.includes(kw));
-  const keywordInAssistant = !keywordInUser && DECISION_KEYWORDS.some((kw) => assistantText.includes(kw));
-  const keywordHit = keywordInUser || keywordInAssistant && userAffirmed;
-  const implicitHit = !keywordHit && (IMPLICIT_ACTION_PATTERNS.some((p) => p.test(`${turn.user_message} ${turn.claude_reply}`)) || IMPLICIT_USER_COMMITMENT_PATTERNS.some((p) => p.test(turn.user_message)));
-  if (!keywordHit && !implicitHit) {
+  const capture = await getCaptureSettings(projectId);
+  const gate = (0, import_shared5.captureGate)(turn, capture);
+  if (!gate.reachesModel) {
     return null;
   }
-  const extracted = await extractDecision(turn);
-  if (!extracted.decision || extracted.confidence < config2.decisionConfidenceMin) {
+  const extracted = await extractDecision(turn, capture);
+  if (!extracted.decision || extracted.confidence < (0, import_shared5.effectiveConfidenceMin)(capture, config2.decisionConfidenceMin)) {
     return null;
   }
   const scope = inferScope(turn, extracted);
@@ -22924,22 +23236,23 @@ async function classifyDecision(turn, projectId) {
     extracted
   };
 }
-async function extractDecision(turn) {
+async function extractDecision(turn, capture) {
   const empty = () => ({ decision: null, rationale: null, rejected: [], confidence: 0 });
   try {
-    const extracted = await (0, import_shared4.extractDecisionLlm)(turn.user_message, turn.claude_reply, {
+    const extracted = await (0, import_shared5.extractDecisionLlm)(turn.user_message, turn.claude_reply, {
       provider: config2.llmProvider,
       anthropicApiKey: config2.anthropicApiKey,
       anthropicModel: config2.anthropicModel,
       openaiApiKey: config2.openaiApiKey,
       openaiModel: config2.openaiLlmModel,
       openaiBaseUrl: config2.openaiBaseUrl,
-      extraSystemRules: import_shared4.SELF_HOSTED_USER_RULE_OVERRIDE
+      extraSystemRules: import_shared5.SELF_HOSTED_USER_RULE_OVERRIDE,
+      capture
     });
     lastClassifierFailure = null;
     return extracted;
   } catch (err) {
-    if (err instanceof import_shared4.LlmKeyMissingError) {
+    if (err instanceof import_shared5.LlmKeyMissingError) {
       console.error(`[Sensing] ${err.message} \u2014 skipping decision extraction`);
       return empty();
     }
@@ -23014,67 +23327,15 @@ function clearSessionEmbeddings(sessionId) {
   embeddingWindows.delete(sessionId);
   recentFilesPerSession.delete(sessionId);
 }
-var import_shared4, lastClassifierFailure, DECISION_KEYWORDS, AFFIRMATION_PATTERNS, IMPLICIT_ACTION_PATTERNS, IMPLICIT_USER_COMMITMENT_PATTERNS, embeddingWindows, recentFilesPerSession;
+var import_shared5, lastClassifierFailure, embeddingWindows, recentFilesPerSession;
 var init_classifiers = __esm({
   "src/classifiers/index.ts"() {
     "use strict";
-    import_shared4 = __toESM(require_dist(), 1);
+    import_shared5 = __toESM(require_dist(), 1);
     init_config();
     init_embeddings();
+    init_capture_settings();
     lastClassifierFailure = null;
-    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"
-    ];
-    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
-    ];
-    IMPLICIT_ACTION_PATTERNS = [
-      /import .+ from ['"][^'"]+['"]/,
-      /require\(['"][^'"]+['"]\)/,
-      /npm install|pnpm add|yarn add/
-    ];
-    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
-    ];
     embeddingWindows = /* @__PURE__ */ new Map();
     recentFilesPerSession = /* @__PURE__ */ new Map();
   }
@@ -23364,7 +23625,7 @@ function resolveSessionId(raw) {
 function buildServer() {
   const server = new McpServer({
     name: "sensing-mcp",
-    version: "2.4.10"
+    version: "2.5.0"
   });
   server.tool(
     "sensing_start_session",
@@ -23384,6 +23645,7 @@ function buildServer() {
       const sessionId = resolveSessionId(session_id);
       sessionRegistry.register(sessionId, project_id);
       const summaryResult = await fetchAlwaysOnSummary(project_id);
+      if (!isThinMode()) void getCaptureSettings(project_id);
       console.error(`[Sensing] Session started: ${sessionId} (${project_id})`);
       return {
         content: [{
@@ -23431,9 +23693,9 @@ function buildServer() {
           console.error(`[Sensing] Unknown session adopted: ${session_id} (${session.project_id})`);
         }
       }
-      const redactedUser = (0, import_shared5.redactSecrets)(user_message);
-      const redactedReply = (0, import_shared5.redactSecrets)(claude_reply);
-      const secretsRedacted = (0, import_shared5.totalRedactions)(redactedUser.redactions) + (0, import_shared5.totalRedactions)(redactedReply.redactions);
+      const redactedUser = (0, import_shared6.redactSecrets)(user_message);
+      const redactedReply = (0, import_shared6.redactSecrets)(claude_reply);
+      const secretsRedacted = (0, import_shared6.totalRedactions)(redactedUser.redactions) + (0, import_shared6.totalRedactions)(redactedReply.redactions);
       if (secretsRedacted > 0) {
         console.error(`[Sensing] Redacted ${secretsRedacted} secret(s) from turn ${sequence} before buffering`);
       }
@@ -23650,17 +23912,18 @@ async function fetchAlwaysOnSummary(projectId) {
     return { text: `Project: ${projectId}` };
   }
 }
-var import_shared5, sessionRegistry, lastDecisionShipFailure, pendingConflictNotices;
+var import_shared6, sessionRegistry, lastDecisionShipFailure, pendingConflictNotices;
 var init_server3 = __esm({
   "src/server.ts"() {
     "use strict";
     init_mcp();
     init_zod();
-    import_shared5 = __toESM(require_dist(), 1);
+    import_shared6 = __toESM(require_dist(), 1);
     init_buffer();
     init_classifiers();
     init_router();
     init_config();
+    init_capture_settings();
     init_pending_notices();
     init_session_registry();
     sessionRegistry = new SessionRegistry(config2.sessionRegistryPath);
@@ -23763,8 +24026,8 @@ var StdioServerTransport = class {
 };
 
 // src/index.ts
-var import_shared6 = __toESM(require_dist(), 1);
-(0, import_shared6.loadEnv)();
+var import_shared7 = __toESM(require_dist(), 1);
+(0, import_shared7.loadEnv)();
 process.on("unhandledRejection", (reason) => {
   console.error("[Sensing] Unhandled rejection (process kept alive):", reason);
 });

package/vendor/sensing-mcp/package.json

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