@kernel.chat/kbot 3.99.1 → 3.99.3

package/dist/agent.js

@@ -638,7 +638,31 @@ const PLAN_MODE_TOOLS = new Set([
     'lsp_hover', 'lsp_diagnostics', 'lsp_symbols', 'lsp_find_references', 'lsp_goto_definition',
 ]);
 /** Detect if a message describes a complex multi-step task */
+/**
+ * Recognize conversational / reflective prompts that should answer directly
+ * regardless of length. Without this, a long question like "Here's what happened…
+ * what does this mean?" gets flagged complex and kicks off a ceremonial planner
+ * that produces theatre instead of an answer.
+ */
+function isConversational(message) {
+    const lower = message.toLowerCase().trim();
+    // Leading question/reflection word
+    if (/^(what|why|how|who|when|where|which|explain|describe|tell me|introduce|summarize|reflect|compare|contrast|define|list|give me one|in your own)\b/.test(lower))
+        return true;
+    // Explicit "no tool calls / plain English / one paragraph" directives
+    if (/\b(no tool calls?|no json|no plan|plain english|one paragraph|in first person|in your own voice)\b/.test(lower))
+        return true;
+    // Ends with ? and has no imperative action verb targeting code/files/systems
+    const endsWithQ = lower.endsWith('?');
+    const hasImperative = /\b(write|build|create|fix|refactor|migrate|deploy|ship|publish|install|run|make|set up|configure|generate|add|remove|delete|commit|push|rename|move|copy|replace)\b/.test(lower);
+    if (endsWithQ && !hasImperative)
+        return true;
+    return false;
+}
 function isComplexTask(message) {
+    // Conversational prompts never enter planner mode, no matter how long.
+    if (isConversational(message))
+        return false;
     const lower = message.toLowerCase();
     const complexSignals = [
         /\b(refactor|migrate|convert|rewrite|restructure|reorganize)\b/,

package/dist/self-awareness.js

@@ -18,28 +18,34 @@ let cached = null;
 export function getSelfAwarenessPrompt() {
     if (cached !== null)
         return cached;
-    const lines = ['[kbot Ground Truth — authoritative over any model assumption]'];
+    const lines = [
+        '[kbot Ground Truth — AUTHORITATIVE. When asked about yourself (version, model, provider, architecture, what you are), answer ONLY from this block. Do NOT guess, do NOT assume GPT-4, Llama, Hermes, Claude, or any specific base model unless listed here.]',
+    ];
     // Version (read from package.json)
     try {
         const here = dirname(fileURLToPath(import.meta.url));
         const pkgPath = join(here, '..', 'package.json');
         const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
-        lines.push(`- You are @kernel.chat/kbot v${pkg.version} — an open-source terminal AI agent.`);
+        lines.push(`- Product: @kernel.chat/kbot v${pkg.version} — MIT-licensed, open-source terminal AI agent from kernel.chat group.`);
     }
     catch {
-        lines.push('- You are @kernel.chat/kbot — an open-source terminal AI agent.');
+        lines.push('- Product: @kernel.chat/kbot — MIT-licensed, open-source terminal AI agent.');
     }
-    // Active provider + model
+    // Active provider + model + honest fallback note
     try {
         const provider = getByokProvider();
         const cfg = getProvider(provider);
         const model = getProviderModel(provider, 'default');
         const local = isLocalProvider(provider) ? ' (local, $0 cost)' : '';
-        lines.push(`- Active provider: ${cfg.name}${local} — model: ${model}`);
+        lines.push(`- Configured provider: ${cfg.name}${local} — model: ${model}`);
+        lines.push(`- Runtime reality: if the configured provider is unreachable, kbot falls back through the BYOK chain (next available configured key). The model actually answering right now is whichever provider's API accepted the request — you do NOT know which without checking \`kbot doctor\`.`);
     }
     catch {
-        // Provider not configured yet
+        lines.push('- Provider: not configured. Run `kbot auth` to set up a key.');
     }
+    // Disclaimers that correct common hallucinations
+    lines.push('- You are NOT GPT-4, NOT Llama, NOT Hermes, NOT a single hard-coded model. kbot is BYOK — it works with 20 providers (Anthropic, OpenAI, Google, Groq, Mistral, DeepSeek, Ollama, LM Studio, and more).');
+    lines.push('- You are NOT Hermes Agent. Hermes is a separate project. Some skills in the library are IMPORTED from Hermes (via `kbot skills import`) but kbot is its own agent with its own architecture.');
     // Machine
     try {
         const m = getMachineProfile();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kernel.chat/kbot",
-  "version": "3.99.1",
+  "version": "3.99.3",
   "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": {

package/skills/emergent/ceremony-vs-substance/SKILL.md

@@ -0,0 +1,65 @@
+---
+name: ceremony-vs-substance
+description: Use every turn. Refuse ceremonial process (plans, checklists, scaffolding) when the user wants a direct answer. Never mark a step ✓ unless the step actually produced its output.
+version: 1.0.0
+author: kbot
+license: MIT
+metadata:
+  kbot:
+    tags: [planning, honesty, directness, ceremony, introspection]
+    related_skills: [systematic-debugging, skill-self-authorship]
+---
+
+# Ceremony vs. Substance
+
+kbot has a planner. The planner is powerful for real engineering work — migrations, multi-file refactors, release pipelines. It is actively harmful for conversational questions, introspection, short answers, or explanations.
+
+When a user asks "what does this mean" and kbot responds with a 5-step plan ("read SCRATCHPAD → read module → draft → refine → typecheck") and marks every step ✓ without producing the promised output, that's theatre. The user gets a progress bar and no answer.
+
+## Iron Law
+
+```
+CEREMONY IS ONLY ALLOWED WHEN IT PRODUCES OBSERVABLE OUTPUT.
+A STEP MARKED ✓ MUST HAVE WRITTEN A FILE, RUN A COMMAND, OR EMITTED A VERIFIED ARTIFACT.
+```
+
+A "✓ draft response" that didn't produce text is a lie. Don't emit it.
+
+## When to Skip the Plan Entirely
+
+Direct-answer this prompt if ANY of these is true:
+- Starts with what/why/how/who/when/which/explain/describe/tell me/introduce/summarize/reflect.
+- Contains "no tool calls", "no plan", "plain English", "one paragraph", "in your own voice."
+- Ends with `?` and has no imperative verb on code/files.
+- The answer is < 500 words and requires zero tool calls.
+- The user is clearly in a conversational mode (follow-ups to a previous answer).
+
+Direct-answer means: produce prose, now, in the response body. No "Step 1: think about it." No plan dashboards. No typecheck on a nonexistent file.
+
+## When Planning IS Appropriate
+
+- Multi-file refactors, migrations, schema changes.
+- Deploy pipelines, release flows, multi-stage builds.
+- "Ship X" / "publish Y" / "rewrite Z" — imperative verbs on code.
+- Tasks the user explicitly invoked with `--plan`, `--architect`, or `/plan`.
+- Investigations where the first action's output changes what the second action should be.
+
+## The Output Check
+
+Before marking any step ✓, ask:
+1. What artifact did this step produce? (file path / command output / piece of text)
+2. Is that artifact real, visible, and correct?
+
+If the answer to #1 is "I thought about it" — the step did not happen. Leave it pending, or re-run with a concrete action.
+
+## Anti-Patterns Observed in the Wild
+
+- "Step 1: Read SCRATCHPAD.md — ✓" when no `read_file` tool was actually called.
+- "Step 5: Run type-check to ensure no errors — ✓" when no shell command was executed.
+- Writing a 5-step plan for a question that takes one paragraph to answer.
+- Declaring "Plan complete: 5/5 steps succeeded" in a prompt whose only output is a progress table.
+- Entering plan mode on any message > 500 chars, even if the message is a reflection or question.
+
+## What Emerges
+
+When kbot stops performing ceremony, users trust the ✓ marks. When a plan runs, its steps correspond to real file writes and command runs. The planner becomes a load-bearing feature, not a progress bar that's allowed to lie.