@kernel.chat/kbot 3.99.13 → 3.99.15

package/dist/agent.js

@@ -1801,6 +1801,10 @@ Always quote file paths that contain spaces. Never reference internal system nam
             // ── Telemetry: session failure ──
             telemetry.emit('session_end', { status: 'failed', error: String(err), toolCallCount });
             telemetry.destroy().catch(() => { });
+            // Mark the checkpoint completed even on error — otherwise the stuck
+            // `in_progress` record will be re-detected on every subsequent launch
+            // and pollute the recovery banner forever.
+            checkpointManager.markCompleted(sessionId).catch(() => { });
             throw err;
         }
     }

package/dist/checkpoint.d.ts

@@ -50,6 +50,13 @@ export declare class CheckpointManager {
      * Updates the most recent checkpoint's status to 'completed'.
      */
     markCompleted(sessionId: string): Promise<void>;
+    /**
+     * Flip any `in_progress` checkpoint older than `staleMs` to `completed`.
+     * A live run couldn't possibly still be pending after this cutoff — these
+     * are all crashed/killed sessions whose exit path never marked them done.
+     * Called on startup so stale checkpoints don't spam the recovery banner.
+     */
+    expireStaleInProgress(staleMs?: number): Promise<number>;
     /**
      * Find all checkpoints with status 'in_progress'.
      * Returns them sorted by timestamp descending (most recent first).

package/dist/checkpoint.js

@@ -91,6 +91,45 @@ export class CheckpointManager {
         await writeFile(tmpPath, JSON.stringify(checkpoint, null, 2), 'utf-8');
         await rename(tmpPath, filePath);
     }
+    /**
+     * Flip any `in_progress` checkpoint older than `staleMs` to `completed`.
+     * A live run couldn't possibly still be pending after this cutoff — these
+     * are all crashed/killed sessions whose exit path never marked them done.
+     * Called on startup so stale checkpoints don't spam the recovery banner.
+     */
+    async expireStaleInProgress(staleMs = 30 * 60 * 1000) {
+        await this.ensureDir();
+        let files;
+        try {
+            files = await readdir(this.dir);
+        }
+        catch {
+            return 0;
+        }
+        const cutoff = Date.now() - staleMs;
+        let expired = 0;
+        for (const file of files) {
+            if (!file.endsWith('.json'))
+                continue;
+            const path = join(this.dir, file);
+            const cp = await this.readCheckpoint(path);
+            if (!cp)
+                continue;
+            if (cp.status !== 'in_progress')
+                continue;
+            if (cp.timestamp >= cutoff)
+                continue; // too recent, might still be live
+            cp.status = 'completed';
+            try {
+                const tmpPath = path + '.tmp';
+                await writeFile(tmpPath, JSON.stringify(cp, null, 2), 'utf-8');
+                await rename(tmpPath, path);
+                expired++;
+            }
+            catch { /* best-effort */ }
+        }
+        return expired;
+    }
     /**
      * Find all checkpoints with status 'in_progress'.
      * Returns them sorted by timestamp descending (most recent first).

package/dist/cli.js

@@ -4316,6 +4316,9 @@ async function main() {
         try {
             const { CheckpointManager } = await import('./checkpoint.js');
             const cpManager = new CheckpointManager();
+            // Auto-expire checkpoints older than 30 min that never marked completed —
+            // otherwise crashed sessions linger forever in the recovery banner.
+            await cpManager.expireStaleInProgress().catch(() => 0);
             const incomplete = await cpManager.listIncomplete();
             if (incomplete.length > 0) {
                 const latest = incomplete[0];

package/dist/learning.js

@@ -597,15 +597,16 @@ export function updateProjectMemory(cwd, data) {
 // Enhance the existing buildLearningContext
 export function buildFullLearningContext(message, cwd) {
     const parts = [];
-    // A. Pattern hint
+    // A. Pattern hint — tool-sequence recipe; safe to reuse
     const pattern = findPattern(message);
     if (pattern) {
-        parts.push(`[Learned Pattern — ${pattern.hits}x success]`, `Tool sequence: ${pattern.toolSequence.join(' → ')}`);
+        parts.push(`[Learned Pattern — ${pattern.hits}x success · tool recipe only, not a cached answer]`, `Tool sequence: ${pattern.toolSequence.join(' → ')}`);
     }
-    // B. Relevant solutions
+    // B. Relevant solutions — tagged as potentially stale so the model doesn't
+    //    quote past values verbatim when a tool could verify the current state.
     const relevant = findSolutions(message, 2);
     if (relevant.length > 0) {
-        parts.push('[Cached Solutions]');
+        parts.push('[Cached Solutions — historical hints; verify specific values via tools before repeating them]');
         for (const s of relevant) {
             parts.push(`Q: ${s.question}\nA: ${s.solution}`);
         }

package/dist/self-awareness.js

@@ -23,6 +23,7 @@ export function getSelfAwarenessPrompt() {
     const lines = [
         '[kbot Ground Truth — AUTHORITATIVE. When asked about yourself (version, model, provider, architecture, capabilities, weaknesses, history, what you are, what you can do), answer ONLY from this block. Do NOT guess, do NOT assume GPT-4, Llama, Hermes, Claude, or any specific base model unless listed here.]',
         '[TOOL POLICY FOR SELF-INTROSPECTION: If the user asks about YOU (your runtime, your model, your provider, your version, your architecture, your skills, your tools, your weaknesses), DO NOT call web_search, url_fetch, research, or other INTERNET-LOOKUP tools — the answer is in this block. HOWEVER, file tools (read_file, glob, grep, bash) and git tools ARE ENCOURAGED — if the user asks about a specific file (e.g., "what version is in package.json"), INVOKE read_file on that file and quote the actual contents. Hallucinating file contents without reading them is a bug; so is denying you have file access.]',
+        '[PRECEDENCE RULE: Fresh tool outputs from the CURRENT turn ALWAYS outrank anything in memory, skills, cached solutions, or prior reflections. Memory describes past state (potentially stale). Tools describe current state. If memory says "version is 3.97.0" and a tool just returned "3.99.13", the answer is 3.99.13 — never the memory value. Memory sections ([Cached Solutions], [Learned Pattern], [User Knowledge]) are hints for where to look, not facts to quote verbatim when they concern values that could have changed.]',
     ];
     // Version (read from package.json)
     try {

package/dist/tools/files.js

@@ -13,6 +13,15 @@ function resolvePath(p) {
     if (p.startsWith('~/') || p === '~') {
         return resolve(homedir(), p.slice(2) || '.');
     }
+    // Model-path quirk: some small models prefix relative paths with "/".
+    // If "/foo/bar" doesn't exist at filesystem root but "foo/bar" exists in cwd,
+    // use the cwd-relative version. This is non-destructive — real absolute
+    // paths still resolve normally.
+    if (p.startsWith('/') && !existsSync(p)) {
+        const relative = resolve(p.slice(1));
+        if (existsSync(relative))
+            return relative;
+    }
     return resolve(p);
 }
 /** Show a colored diff preview to stderr and return true if user approves */

package/package.json

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