@kernel.chat/kbot 3.99.22 → 3.99.23

package/dist/agent.js

@@ -41,6 +41,7 @@ import { CheckpointManager, newSessionId } from './checkpoint.js';
 import { TelemetryEmitter } from './telemetry.js';
 import { loadSkills } from './skills-loader.js';
 import { getSelfAwarenessPrompt } from './self-awareness.js';
+import { buildMathGuardBlock } from './math-guard.js';
 import { queueSignal, getCollectiveRecommendation, isCollectiveEnabled } from './collective.js';
 import { subscribeToBlackboard } from './agent-protocol.js';
 import { ActiveInferenceEngine } from './free-energy.js';
@@ -946,6 +947,7 @@ export async function runAgent(message, options = {}) {
     const contextSnippet = options.context ? formatContextForPrompt(options.context) : '';
     const skillsSnippet = loadSkills(process.cwd(), message);
     const selfAwarenessSnippet = getSelfAwarenessPrompt();
+    const mathGuardSnippet = buildMathGuardBlock(message);
     const memorySnippet = getMemoryPrompt();
     const learningContext = buildFullLearningContext(message, process.cwd());
     const synthesisSnippet = getSynthesisContext(8); // Three-tier memory: reflection layer insights
@@ -1065,7 +1067,7 @@ Always quote file paths that contain spaces. Never reference internal system nam
     const promptSections = createPromptSections({
         persona: PERSONA,
         matrixPrompt: matrixPrompt || undefined,
-        contextSnippet: (contextSnippet || '') + repoMapSnippet + graphSnippet + skillsSnippet + skillLibrarySnippet + '\n\n' + selfAwarenessSnippet || undefined,
+        contextSnippet: (contextSnippet || '') + repoMapSnippet + graphSnippet + skillsSnippet + skillLibrarySnippet + '\n\n' + selfAwarenessSnippet + (mathGuardSnippet ? '\n\n' + mathGuardSnippet : '') || undefined,
         memorySnippet: (memorySnippet || '') + getDreamPrompt(8) + reflectionSnippet || undefined,
         learningContext: ((learningContext || '') + (synthesisSnippet ? '\n\n' + synthesisSnippet : '') + (correctionsSnippet ? '\n\n' + correctionsSnippet : '')) || undefined,
     });

package/dist/math-guard.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Math guard — pre-computes arithmetic in user messages.
+ *
+ * Reality-check probes (2026-04-20) showed kbot answering "847 × 239 = 1,985,633"
+ * (correct: 202,433) — an order-of-magnitude RF-16 arithmetic error. This module
+ * scans the user message for basic arithmetic expressions, evaluates them in JS,
+ * and returns a ground-truth block to prepend so the LLM sees the correct answer
+ * as input rather than relying on learned priors.
+ *
+ * Scope: single-operator expressions only — `a op b` where op ∈ {+,-,*,×,/,÷,%}.
+ * Compound expressions, parentheses, unary minus: not handled. The failure mode
+ * when this module doesn't match is "guard did not fire" — the LLM sees the raw
+ * message unchanged, same as today. So false negatives are safe.
+ *
+ * No eval(), no Function(). Pure regex + arithmetic.
+ */
+export interface ComputedExpression {
+    expression: string;
+    result: number;
+}
+/**
+ * Find every `a op b` in the message and compute it.
+ *
+ * Returns at most 10 distinct expressions per message — more than that and the
+ * user is probably pasting a table, not asking for arithmetic help.
+ */
+export declare function extractArithmetic(message: string): ComputedExpression[];
+/**
+ * Ground-truth preamble to prepend to the user message (or system prompt).
+ * Returns empty string when no arithmetic is detected — callers can
+ * concatenate unconditionally.
+ */
+export declare function buildMathGuardBlock(message: string): string;
+//# sourceMappingURL=math-guard.d.ts.map

package/dist/math-guard.js

@@ -0,0 +1,92 @@
+/**
+ * Math guard — pre-computes arithmetic in user messages.
+ *
+ * Reality-check probes (2026-04-20) showed kbot answering "847 × 239 = 1,985,633"
+ * (correct: 202,433) — an order-of-magnitude RF-16 arithmetic error. This module
+ * scans the user message for basic arithmetic expressions, evaluates them in JS,
+ * and returns a ground-truth block to prepend so the LLM sees the correct answer
+ * as input rather than relying on learned priors.
+ *
+ * Scope: single-operator expressions only — `a op b` where op ∈ {+,-,*,×,/,÷,%}.
+ * Compound expressions, parentheses, unary minus: not handled. The failure mode
+ * when this module doesn't match is "guard did not fire" — the LLM sees the raw
+ * message unchanged, same as today. So false negatives are safe.
+ *
+ * No eval(), no Function(). Pure regex + arithmetic.
+ */
+const EXPR_RE = /(?<!\w)(-?\d+(?:\.\d+)?)\s*([+\-*×/÷%])\s*(-?\d+(?:\.\d+)?)(?!\w)/g;
+function normalizeOp(op) {
+    switch (op) {
+        case '+': return '+';
+        case '-': return '-';
+        case '*':
+        case '×': return '*';
+        case '/':
+        case '÷': return '/';
+        case '%': return '%';
+        default: return null;
+    }
+}
+function compute(a, op, b) {
+    const norm = normalizeOp(op);
+    if (norm === null)
+        return null;
+    switch (norm) {
+        case '+': return a + b;
+        case '-': return a - b;
+        case '*': return a * b;
+        case '/': return b === 0 ? null : a / b;
+        case '%': return b === 0 ? null : a % b;
+    }
+}
+function formatResult(n) {
+    if (!Number.isFinite(n))
+        return String(n);
+    if (Number.isInteger(n))
+        return n.toString();
+    // Trim long floats; six digits is plenty for user-facing answers.
+    return Number.parseFloat(n.toFixed(6)).toString();
+}
+/**
+ * Find every `a op b` in the message and compute it.
+ *
+ * Returns at most 10 distinct expressions per message — more than that and the
+ * user is probably pasting a table, not asking for arithmetic help.
+ */
+export function extractArithmetic(message) {
+    if (!message)
+        return [];
+    const out = [];
+    const seen = new Set();
+    for (const m of message.matchAll(EXPR_RE)) {
+        const raw = m[0].trim();
+        if (seen.has(raw))
+            continue;
+        seen.add(raw);
+        const a = Number.parseFloat(m[1]);
+        const b = Number.parseFloat(m[3]);
+        const r = compute(a, m[2], b);
+        if (r === null || !Number.isFinite(r))
+            continue;
+        out.push({ expression: raw, result: r });
+        if (out.length >= 10)
+            break;
+    }
+    return out;
+}
+/**
+ * Ground-truth preamble to prepend to the user message (or system prompt).
+ * Returns empty string when no arithmetic is detected — callers can
+ * concatenate unconditionally.
+ */
+export function buildMathGuardBlock(message) {
+    const exprs = extractArithmetic(message);
+    if (exprs.length === 0)
+        return '';
+    const lines = exprs.map(e => `  ${e.expression} = ${formatResult(e.result)}`);
+    return ('[MATH GUARD — computed deterministically in JS; use these values verbatim, ' +
+        'do not recompute and do not contradict]\n' +
+        lines.join('\n') +
+        '\n');
+}
+//# sourceMappingURL=math-guard.js.map

package/dist/self-awareness.js

@@ -31,6 +31,7 @@ export function getSelfAwarenessPrompt() {
         const pkgPath = join(here, '..', 'package.json');
         const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
         lines.push(`- Product: @kernel.chat/kbot v${pkg.version} — MIT-licensed, open-source terminal AI agent from kernel.chat group.`);
+        lines.push(`- VERSION RULE: when asked your version, the answer is EXACTLY "${pkg.version}". Not 3.99.14, not 3.97.0, not any other number. If you cite a version number that is not "${pkg.version}" you are wrong — the value above is read at startup from the installed package.json.`);
     }
     catch {
         lines.push('- Product: @kernel.chat/kbot — MIT-licensed, open-source terminal AI agent.');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kernel.chat/kbot",
-  "version": "3.99.22",
+  "version": "3.99.23",
   "description": "Open-source terminal AI agent. 787+ tools, 35 agents, 20 providers. Dreams, learns, watches your system. Controls your phone. Fully local, fully sovereign. MIT.",
   "type": "module",
   "repository": {