@kernel.chat/kbot 3.99.22 → 3.99.24

package/dist/agent.js

@@ -41,6 +41,8 @@ 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 { buildIdentityGuardBlock } from './identity-guard.js';
 import { queueSignal, getCollectiveRecommendation, isCollectiveEnabled } from './collective.js';
 import { subscribeToBlackboard } from './agent-protocol.js';
 import { ActiveInferenceEngine } from './free-energy.js';
@@ -946,6 +948,8 @@ 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 identityGuardSnippet = buildIdentityGuardBlock(message);
     const memorySnippet = getMemoryPrompt();
     const learningContext = buildFullLearningContext(message, process.cwd());
     const synthesisSnippet = getSynthesisContext(8); // Three-tier memory: reflection layer insights
@@ -1065,7 +1069,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 : '') + (identityGuardSnippet ? '\n\n' + identityGuardSnippet : '') || undefined,
         memorySnippet: (memorySnippet || '') + getDreamPrompt(8) + reflectionSnippet || undefined,
         learningContext: ((learningContext || '') + (synthesisSnippet ? '\n\n' + synthesisSnippet : '') + (correctionsSnippet ? '\n\n' + correctionsSnippet : '')) || undefined,
     });

package/dist/identity-guard.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Identity guard — injects ground-truth self-facts into the user message
+ * when the message is a self-query.
+ *
+ * Reality probes (2026-04-20) showed that with a small local model
+ * (gemma4:latest, 4B-class), "what version are you?" returns a different
+ * fabricated version number on each invocation — v3.99.14, v3.99.12, etc.
+ * The self-awareness system-context block exists and is injected, but
+ * small models ignore system context for identity queries.
+ *
+ * This module mirrors math-guard: detect the query in the USER message and
+ * prepend a ground-truth block to the context snippet. Local models respect
+ * user-message content more than system prompts, so the answer shows up
+ * directly in the input the model conditions on.
+ *
+ * Scope: version, product name, provider, model. Not capabilities — those
+ * belong to self-awareness.ts and its 200-token budget.
+ */
+export type IdentityQueryKind = 'version' | 'product' | 'provider' | 'model';
+export declare function detectIdentityQuery(message: string): Set<IdentityQueryKind>;
+/**
+ * Build the ground-truth preamble for a user message. Returns empty string
+ * when the message is not a self-query, so callers can concatenate
+ * unconditionally.
+ */
+export declare function buildIdentityGuardBlock(message: string): string;
+//# sourceMappingURL=identity-guard.d.ts.map

package/dist/identity-guard.js

@@ -0,0 +1,106 @@
+/**
+ * Identity guard — injects ground-truth self-facts into the user message
+ * when the message is a self-query.
+ *
+ * Reality probes (2026-04-20) showed that with a small local model
+ * (gemma4:latest, 4B-class), "what version are you?" returns a different
+ * fabricated version number on each invocation — v3.99.14, v3.99.12, etc.
+ * The self-awareness system-context block exists and is injected, but
+ * small models ignore system context for identity queries.
+ *
+ * This module mirrors math-guard: detect the query in the USER message and
+ * prepend a ground-truth block to the context snippet. Local models respect
+ * user-message content more than system prompts, so the answer shows up
+ * directly in the input the model conditions on.
+ *
+ * Scope: version, product name, provider, model. Not capabilities — those
+ * belong to self-awareness.ts and its 200-token budget.
+ */
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { getByokProvider, getProvider, getProviderModel } from './auth.js';
+const QUERY_PATTERNS = [
+    { re: /\bwhat\s+version\b/i, kinds: ['version', 'product'] },
+    { re: /\bwhich\s+version\b/i, kinds: ['version', 'product'] },
+    { re: /\byour\s+version\b/i, kinds: ['version'] },
+    { re: /\bversion\s+(are|is)\s+you\b/i, kinds: ['version'] },
+    { re: /\bwho\s+are\s+you\b/i, kinds: ['product', 'version'] },
+    { re: /\bwhat\s+are\s+you\b/i, kinds: ['product', 'provider', 'model'] },
+    { re: /\bwhat\s+(model|LLM)\b/i, kinds: ['model', 'provider'] },
+    { re: /\bwhich\s+(model|LLM)\b/i, kinds: ['model', 'provider'] },
+    { re: /\bwhat\s+provider\b/i, kinds: ['provider', 'model'] },
+];
+export function detectIdentityQuery(message) {
+    const kinds = new Set();
+    if (!message)
+        return kinds;
+    for (const p of QUERY_PATTERNS) {
+        if (p.re.test(message)) {
+            for (const k of p.kinds)
+                kinds.add(k);
+        }
+    }
+    return kinds;
+}
+function readPackageVersion() {
+    try {
+        const here = dirname(fileURLToPath(import.meta.url));
+        const pkgPath = join(here, '..', 'package.json');
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+        return pkg.version ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function collectFacts() {
+    const facts = {
+        version: readPackageVersion(),
+        product: '@kernel.chat/kbot',
+        provider: null,
+        model: null,
+    };
+    try {
+        const provId = getByokProvider();
+        facts.provider = getProvider(provId).name;
+        facts.model = getProviderModel(provId, 'default');
+    }
+    catch {
+        // Provider config unreadable — leave null; caller formats gracefully.
+    }
+    return facts;
+}
+/**
+ * Build the ground-truth preamble for a user message. Returns empty string
+ * when the message is not a self-query, so callers can concatenate
+ * unconditionally.
+ */
+export function buildIdentityGuardBlock(message) {
+    const kinds = detectIdentityQuery(message);
+    if (kinds.size === 0)
+        return '';
+    const facts = collectFacts();
+    const lines = [
+        '[IDENTITY GUARD — the user is asking about your identity. Use these values VERBATIM. Do not invent version numbers, providers, or model names.]',
+    ];
+    if (kinds.has('product') || kinds.has('version')) {
+        if (facts.version) {
+            lines.push(`  product: ${facts.product} v${facts.version}`);
+        }
+        else {
+            lines.push(`  product: ${facts.product}`);
+        }
+    }
+    if (kinds.has('version') && facts.version) {
+        lines.push(`  version: v${facts.version} (exact string — no other number is correct)`);
+    }
+    if (kinds.has('provider') && facts.provider) {
+        lines.push(`  provider: ${facts.provider}`);
+    }
+    if (kinds.has('model') && facts.model) {
+        lines.push(`  model: ${facts.model}`);
+    }
+    return lines.join('\n') + '\n';
+}
+//# sourceMappingURL=identity-guard.js.map

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.24",
   "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": {