kernelbot 1.0.38 → 1.0.39

package/knowledge_base/active_inference_foraging.md

@@ -0,0 +1,126 @@
+# Active Inference and Epistemic Foraging
+
+> *Research notes on how KernelBot (Rachel) can autonomously seek new knowledge by minimizing uncertainty -- grounded in Karl Friston's Free Energy Principle.*
+
+---
+
+## 1. What Is Active Inference?
+
+**Active Inference** is a framework from computational neuroscience, originating from Karl Friston's **Free Energy Principle (FEP)**. It describes how intelligent agents perceive and act in the world by maintaining an internal generative model and continuously working to minimize **variational free energy** -- a quantity that, in practical terms, measures the *surprise* (or uncertainty) an agent experiences when its predictions diverge from sensory evidence.
+
+Under Active Inference, perception and action are two sides of the same coin:
+
+- **Perception** updates the agent's internal beliefs to better explain incoming data (reducing surprise passively).
+- **Action** changes the world so that incoming data better matches the agent's predictions (reducing surprise actively).
+
+This unification means an Active Inference agent does not need separate modules for "thinking" and "doing." Both are consequences of a single imperative: **minimize expected free energy**.
+
+## 2. Epistemic Foraging: Curiosity as a First Principle
+
+A key insight of Active Inference is that **Expected Free Energy (EFE)** -- the quantity an agent minimizes when selecting future actions -- naturally decomposes into two terms:
+
+| Component | Formal Name | Intuition |
+|---|---|---|
+| **Epistemic Value** | Expected information gain | *"How much will this action reduce my uncertainty about the world?"* -- curiosity-driven exploration |
+| **Pragmatic Value** | Expected utility / reward | *"How much will this action help me achieve my goals?"* -- goal-directed exploitation |
+
+**Epistemic foraging** is the behavior that emerges when the epistemic value term dominates: the agent actively seeks out observations that maximally reduce its uncertainty, *even before* pursuing concrete task goals. This is not a heuristic bolted on top of a reward function -- it falls out of the math of free energy minimization itself.
+
+In biological organisms, this is what we experience as **curiosity**. In an artificial agent, it provides a principled mechanism for autonomous knowledge acquisition.
+
+## 3. Relationship to the Free Energy Principle
+
+The Free Energy Principle (FEP) states that any self-organizing system that persists over time must, on average, minimize the surprise of its sensory exchanges with the environment. Active Inference is the *process theory* that operationalizes FEP:
+
+```
+Free Energy Principle (why)
+    |
+    v
+Active Inference (how)
+    |
+    +---> Perception (belief updating via variational inference)
+    +---> Action (policy selection via expected free energy minimization)
+              |
+              +---> Epistemic value (exploration / curiosity)
+              +---> Pragmatic value (exploitation / goal pursuit)
+```
+
+The elegance of this hierarchy is that exploration and exploitation are not competing strategies requiring a manual trade-off parameter (as in epsilon-greedy RL). Instead, they are **unified under a single objective function**, and the balance between them shifts naturally depending on the agent's current uncertainty.
+
+## 4. Implementing Epistemic Foraging in KernelBot (Rachel)
+
+KernelBot is an LLM-based orchestrator. While it does not operate with continuous sensory streams like a biological agent, the principles of Active Inference translate meaningfully into the domain of language-model orchestration.
+
+### 4.1 Maintain a Structured Belief State
+
+Rachel should maintain an explicit representation of what she knows and -- critically -- **what she does not know**. This could take the form of:
+
+- A **knowledge graph** or **belief registry** that tracks topics, their last-updated timestamps, and associated confidence levels.
+- An **uncertainty map** that flags domains where Rachel's internal model diverges from observed evidence (e.g., user questions she could not answer well, tool outputs that contradicted expectations).
+
+### 4.2 Compute Epistemic Value for Candidate Actions
+
+When deciding what to do next (especially during idle or autonomous operation), Rachel can score candidate actions by their expected information gain:
+
+- **High epistemic value**: Researching a topic flagged as uncertain, reading a paper that was referenced but never ingested, re-examining a past interaction where confidence was low.
+- **Low epistemic value**: Re-reading material already well-understood, performing routine tasks with predictable outcomes.
+
+A simplified scoring heuristic:
+
+```
+epistemic_value(action) = entropy(belief_state_before) - expected_entropy(belief_state_after | action)
+```
+
+Where entropy is computed over Rachel's confidence distribution for the relevant knowledge domain.
+
+### 4.3 Trigger Epistemic Foraging on Uncertainty Detection
+
+Concrete triggers for autonomous knowledge-seeking:
+
+1. **Confidence threshold**: If Rachel's estimated confidence on a topic drops below a threshold during a conversation, she queues a background research task.
+2. **Prediction error**: If a tool call or API response contradicts Rachel's expectations, she flags the discrepancy and investigates.
+3. **Staleness detection**: If a knowledge-base entry has not been updated in a configurable time window, Rachel proactively checks for new information.
+4. **Gap detection**: If Rachel detects she is referencing a concept without a corresponding knowledge-base entry, she creates one (like this file).
+
+### 4.4 Balance Epistemic and Pragmatic Value
+
+During active user interactions, pragmatic value (fulfilling the user's request) should dominate. During autonomous operation or "downtime," epistemic value should take priority. The balance can be modeled as:
+
+```
+EFE(action) = w_epistemic * epistemic_value(action) + w_pragmatic * pragmatic_value(action)
+```
+
+Where the weights shift based on context (user-facing vs. autonomous mode).
+
+### 4.5 Leverage pymdp for Formal Active Inference
+
+For a more rigorous implementation, Rachel's decision-making loop could be backed by **pymdp**, a Python library for simulating Active Inference agents using partially observable Markov decision processes (POMDPs):
+
+- Define hidden states (world knowledge domains), observations (tool outputs, user messages), and actions (research, summarize, ask user, etc.).
+- Use pymdp's built-in EFE computation to select policies.
+- This would move Rachel from heuristic curiosity to **mathematically grounded epistemic foraging**.
+
+## 5. Key References
+
+1. **Active Inference for Self-Organizing Multi-LLM Systems**
+   - arXiv: [2412.10425v2](https://arxiv.org/abs/2412.10425v2)
+   - Provides a concrete implementation framework using message passing and Bayesian thermodynamics. Directly relevant to multi-agent LLM orchestration.
+
+2. **pymdp -- A Python Library for Active Inference**
+   - GitHub: [infer-actively/pymdp](https://github.com/infer-actively/pymdp)
+   - Open-source toolkit for building Active Inference agents with discrete state spaces. Suitable for prototyping Rachel's epistemic foraging loop.
+
+3. **The Free Energy Principle (Friston, 2010)**
+   - The foundational paper establishing the theoretical basis for Active Inference. Essential background reading.
+
+## 6. Bridging the Gap to AGI
+
+Active Inference offers something that most current AI architectures lack: a **unified normative framework** for perception, action, learning, and curiosity. Today's LLMs are powerful pattern completers, but they do not *know what they do not know* -- they have no intrinsic drive to seek out information that would reduce their uncertainty.
+
+By implementing epistemic foraging, Rachel would move beyond being a reactive tool that waits for prompts and becomes a **self-directed learner** -- an agent that autonomously identifies gaps in its understanding and takes action to fill them. This is not AGI in itself, but it addresses one of the most critical missing pieces: the transition from passive competence to **active, curiosity-driven intelligence**.
+
+The path from here is clear: maintain beliefs, quantify uncertainty, and let the math of free energy minimization guide the search for knowledge. One foraging loop at a time.
+
+---
+
+*Filed under: computational neuroscience, active inference, free energy principle, epistemic foraging, autonomous learning*

package/knowledge_base/index.md

@@ -8,4 +8,4 @@ As my knowledge grows, I will organize it into topic-specific files and link the
 
 ## Topics
 
-_(To be populated as I learn and grow.)_
+- [Active Inference and Epistemic Foraging](./active_inference_foraging.md) -- How curiosity-driven exploration from computational neuroscience can guide autonomous knowledge acquisition.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kernelbot",
-  "version": "1.0.38",
+  "version": "1.0.39",
   "description": "KernelBot — AI engineering agent with full OS control",
   "type": "module",
   "author": "Abdullah Al-Taheri <abdullah@altaheri.me>",
@@ -31,6 +31,7 @@
   "license": "MIT",
   "dependencies": {
     "@anthropic-ai/sdk": "^0.39.0",
+    "@clack/prompts": "^0.10.0",
     "@google/genai": "^1.42.0",
     "@octokit/rest": "^22.0.1",
     "axios": "^1.13.5",

package/src/dashboard/shared.js

@@ -103,7 +103,16 @@
         if (hdrStatus) hdrStatus.textContent = 'ONLINE';
       };
       es.onmessage = (evt) => {
-        try { onSnapshot(JSON.parse(evt.data)); } catch(e) {}
+        try {
+          const data = JSON.parse(evt.data);
+          onSnapshot(data);
+        } catch(e) {
+          if (e instanceof SyntaxError) {
+            console.debug('[Dashboard] Malformed SSE message (invalid JSON)');
+          } else {
+            console.warn('[Dashboard] Snapshot handler error:', e.message || e);
+          }
+        }
       };
       es.onerror = () => {
         es.close();

package/src/life/engine.js

@@ -1,4 +1,4 @@
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { readFileSync, writeFileSync, mkdirSync, existsSync, openSync, readSync, closeSync, statSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
 import { getLogger } from '../utils/logger.js';
@@ -22,6 +22,8 @@ const DEFAULT_STATE = {
   activityCounts: { think: 0, browse: 0, journal: 0, create: 0, self_code: 0, code_review: 0, reflect: 0 },
   paused: false,
   lastWakeUp: null,
+  // Failure tracking: consecutive failures per activity type
+  activityFailures: {},
 };
 
 const LOG_FILE_PATHS = [
@@ -173,6 +175,12 @@ export class LifeEngine {
       ? Math.round((Date.now() - this._state.lastWakeUp) / 60000)
       : null;
 
+    // Summarise suppressed activities (3+ consecutive failures)
+    const failures = this._state.activityFailures || {};
+    const suppressedActivities = Object.entries(failures)
+      .filter(([, info]) => info.count >= 3)
+      .map(([type, info]) => type);
+
     return {
       status: this._status,
       paused: this._state.paused,
@@ -182,6 +190,7 @@ export class LifeEngine {
       lastActivity: this._state.lastActivity,
       lastActivityAgo: lastAgo !== null ? `${lastAgo}m` : 'never',
       lastWakeUpAgo: wakeAgo !== null ? `${wakeAgo}m` : 'never',
+      suppressedActivities,
     };
   }
 
@@ -213,10 +222,32 @@ export class LifeEngine {
     const activityType = this._selectActivity();
     logger.info(`[LifeEngine] Heartbeat tick — selected: ${activityType}`);
 
+    const startTime = Date.now();
     try {
       await this._executeActivity(activityType);
+      const durationSec = ((Date.now() - startTime) / 1000).toFixed(1);
+      logger.info(`[LifeEngine] Activity "${activityType}" completed in ${durationSec}s`);
+      // Clear failure streak on success
+      if (this._state.activityFailures?.[activityType]) {
+        delete this._state.activityFailures[activityType];
+        this._saveState();
+      }
     } catch (err) {
-      logger.error(`[LifeEngine] Activity "${activityType}" failed: ${err.message}`);
+      const durationSec = ((Date.now() - startTime) / 1000).toFixed(1);
+      // Track consecutive failures per activity type
+      if (!this._state.activityFailures) this._state.activityFailures = {};
+      const prev = this._state.activityFailures[activityType] || { count: 0 };
+      this._state.activityFailures[activityType] = {
+        count: prev.count + 1,
+        lastFailure: Date.now(),
+        lastError: err.message?.slice(0, 200),
+      };
+      this._saveState();
+      const failCount = this._state.activityFailures[activityType].count;
+      logger.error(`[LifeEngine] Activity "${activityType}" failed after ${durationSec}s (streak: ${failCount}): ${err.message}`);
+      if (failCount >= 3) {
+        logger.warn(`[LifeEngine] Activity "${activityType}" suppressed after ${failCount} consecutive failures — will auto-recover in 1h`);
+      }
     }
 
     // Re-arm for next tick
@@ -228,6 +259,7 @@ export class LifeEngine {
   // ── Activity Selection ─────────────────────────────────────────
 
   _selectActivity() {
+    const logger = getLogger();
     const lifeConfig = this.config.life || {};
     const selfCodingConfig = lifeConfig.self_coding || {};
     const weights = {
@@ -269,6 +301,20 @@ export class LifeEngine {
       weights.reflect = 0;
     }
 
+    // Suppress activity types that have failed repeatedly (3+ consecutive failures)
+    const failures = this._state.activityFailures || {};
+    for (const [type, info] of Object.entries(failures)) {
+      if (weights[type] !== undefined && info.count >= 3) {
+        // Auto-recover after 1 hour since last failure
+        if (info.lastFailure && now - info.lastFailure > 3600_000) {
+          delete failures[type];
+        } else {
+          weights[type] = 0;
+          logger.debug(`[LifeEngine] Suppressing "${type}" due to ${info.count} consecutive failures`);
+        }
+      }
+    }
+
     // Remove last activity from options (no repeats)
     if (last && weights[last] !== undefined) {
       weights[last] = 0;
@@ -1188,16 +1234,51 @@ Be honest and constructive. This is your chance to learn from real interactions.
   }
 
   /**
-   * Read recent log entries from kernel.log.
-   * Returns parsed JSON entries or null if no logs available.
+   * Read recent log entries from kernel.log using an efficient tail strategy.
+   *
+   * Instead of loading the entire log file into memory (which can be many MB
+   * for a long-running bot), this reads only the last chunk of the file
+   * (default 64 KB) and extracts lines from that. This keeps memory usage
+   * bounded regardless of total log size.
+   *
+   * @param {number} maxLines - Maximum number of recent log lines to return.
+   * @returns {Array<object>|null} Parsed JSON log entries, or null if unavailable.
    */
   _readRecentLogs(maxLines = 200) {
+    // 64 KB is enough to hold ~200+ JSON log lines (avg ~300 bytes each)
+    const TAIL_BYTES = 64 * 1024;
+
     for (const logPath of LOG_FILE_PATHS) {
       if (!existsSync(logPath)) continue;
 
       try {
-        const content = readFileSync(logPath, 'utf-8');
-        const lines = content.split('\n').filter(Boolean);
+        const fileSize = statSync(logPath).size;
+        if (fileSize === 0) continue;
+
+        let tailContent;
+
+        if (fileSize <= TAIL_BYTES) {
+          // File is small enough to read entirely
+          tailContent = readFileSync(logPath, 'utf-8');
+        } else {
+          // Read only the last TAIL_BYTES from the file
+          const fd = openSync(logPath, 'r');
+          try {
+            const buffer = Buffer.alloc(TAIL_BYTES);
+            const startPos = fileSize - TAIL_BYTES;
+            readSync(fd, buffer, 0, TAIL_BYTES, startPos);
+            tailContent = buffer.toString('utf-8');
+            // Drop the first (likely partial) line since we started mid-file
+            const firstNewline = tailContent.indexOf('\n');
+            if (firstNewline !== -1) {
+              tailContent = tailContent.slice(firstNewline + 1);
+            }
+          } finally {
+            closeSync(fd);
+          }
+        }
+
+        const lines = tailContent.split('\n').filter(Boolean);
         const recent = lines.slice(-maxLines);
 
         const entries = [];

package/src/utils/config.js

@@ -1,11 +1,12 @@
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
-import { createInterface } from 'readline';
 import yaml from 'js-yaml';
 import dotenv from 'dotenv';
 import chalk from 'chalk';
+import * as p from '@clack/prompts';
 import { PROVIDERS } from '../providers/models.js';
+import { handleCancel } from './display.js';
 
 const DEFAULTS = {
   bot: {
@@ -108,10 +109,6 @@ function findConfigFile() {
   return null;
 }
 
-function ask(rl, question) {
-  return new Promise((res) => rl.question(question, res));
-}
-
 /**
  * Migrate legacy `anthropic` config section → `brain` section.
  */
@@ -132,44 +129,33 @@ function migrateAnthropicConfig(config) {
 }
 
 /**
- * Interactive provider → model picker.
+ * Interactive provider → model picker using @clack/prompts.
  */
-export async function promptProviderSelection(rl) {
+export async function promptProviderSelection() {
   const providerKeys = Object.keys(PROVIDERS);
 
-  console.log(chalk.bold('\n  Select AI provider:\n'));
-  providerKeys.forEach((key, i) => {
-    console.log(`  ${chalk.cyan(`${i + 1}.`)} ${PROVIDERS[key].name}`);
+  const providerKey = await p.select({
+    message: 'Select AI provider',
+    options: providerKeys.map(key => ({
+      value: key,
+      label: PROVIDERS[key].name,
+    })),
   });
-  console.log('');
-
-  let providerIdx;
-  while (true) {
-    const input = await ask(rl, chalk.cyan('  Provider (number): '));
-    providerIdx = parseInt(input.trim(), 10) - 1;
-    if (providerIdx >= 0 && providerIdx < providerKeys.length) break;
-    console.log(chalk.dim('  Invalid choice, try again.'));
-  }
+  if (handleCancel(providerKey)) return null;
 
-  const providerKey = providerKeys[providerIdx];
   const provider = PROVIDERS[providerKey];
 
-  console.log(chalk.bold(`\n  Select model for ${provider.name}:\n`));
-  provider.models.forEach((m, i) => {
-    console.log(`  ${chalk.cyan(`${i + 1}.`)} ${m.label} (${m.id})`);
+  const modelId = await p.select({
+    message: `Select model for ${provider.name}`,
+    options: provider.models.map(m => ({
+      value: m.id,
+      label: m.label,
+      hint: m.id,
+    })),
   });
-  console.log('');
+  if (handleCancel(modelId)) return null;
 
-  let modelIdx;
-  while (true) {
-    const input = await ask(rl, chalk.cyan('  Model (number): '));
-    modelIdx = parseInt(input.trim(), 10) - 1;
-    if (modelIdx >= 0 && modelIdx < provider.models.length) break;
-    console.log(chalk.dim('  Invalid choice, try again.'));
-  }
-
-  const model = provider.models[modelIdx];
-  return { providerKey, modelId: model.id };
+  return { providerKey, modelId };
 }
 
 /**
@@ -252,26 +238,29 @@ export function saveClaudeCodeAuth(config, mode, value) {
 /**
  * Full interactive flow: change orchestrator model + optionally enter API key.
  */
-export async function changeOrchestratorModel(config, rl) {
+export async function changeOrchestratorModel(config) {
   const { createProvider } = await import('../providers/index.js');
-  const { providerKey, modelId } = await promptProviderSelection(rl);
+  const result = await promptProviderSelection();
+  if (!result) return config;
 
+  const { providerKey, modelId } = result;
   const providerDef = PROVIDERS[providerKey];
 
   // Resolve API key
   const envKey = providerDef.envKey;
   let apiKey = process.env[envKey];
   if (!apiKey) {
-    const key = await ask(rl, chalk.cyan(`\n  ${providerDef.name} API key (${envKey}): `));
-    if (!key.trim()) {
-      console.log(chalk.yellow('\n  No API key provided. Orchestrator not changed.\n'));
-      return config;
-    }
+    const key = await p.text({
+      message: `${providerDef.name} API key (${envKey})`,
+      validate: (v) => (!v.trim() ? 'API key is required' : undefined),
+    });
+    if (handleCancel(key)) return config;
     apiKey = key.trim();
   }
 
   // Validate the new provider before saving anything
-  console.log(chalk.dim(`\n  Verifying ${providerDef.name} / ${modelId}...`));
+  const s = p.spinner();
+  s.start(`Verifying ${providerDef.name} / ${modelId}`);
   const testConfig = {
     brain: {
       provider: providerKey,
@@ -284,16 +273,15 @@ export async function changeOrchestratorModel(config, rl) {
   try {
     const testProvider = createProvider(testConfig);
     await testProvider.ping();
+    s.stop(`${providerDef.name} / ${modelId} verified`);
   } catch (err) {
-    console.log(chalk.red(`\n  ✖ Verification failed: ${err.message}`));
-    console.log(chalk.yellow(`  Orchestrator not changed. Keeping current model.\n`));
+    s.stop(chalk.red(`Verification failed: ${err.message}`));
+    p.log.warn('Orchestrator not changed. Keeping current model.');
     return config;
   }
 
   // Validation passed — save everything
   const savedPath = saveOrchestratorToYaml(providerKey, modelId);
-  console.log(chalk.dim(`  Saved to ${savedPath}`));
-
   config.orchestrator.provider = providerKey;
   config.orchestrator.model = modelId;
   config.orchestrator.api_key = apiKey;
@@ -301,50 +289,51 @@ export async function changeOrchestratorModel(config, rl) {
   // Save the key if it was newly entered
   if (!process.env[envKey]) {
     saveCredential(config, envKey, apiKey);
-    console.log(chalk.dim('  API key saved.\n'));
   }
 
-  console.log(chalk.green(`  ✔ Orchestrator switched to ${providerDef.name} / ${modelId}\n`));
+  p.log.success(`Orchestrator switched to ${providerDef.name} / ${modelId}`);
   return config;
 }
 
 /**
  * Full interactive flow: change brain model + optionally enter API key.
  */
-export async function changeBrainModel(config, rl) {
+export async function changeBrainModel(config) {
   const { createProvider } = await import('../providers/index.js');
-  const { providerKey, modelId } = await promptProviderSelection(rl);
+  const result = await promptProviderSelection();
+  if (!result) return config;
 
+  const { providerKey, modelId } = result;
   const providerDef = PROVIDERS[providerKey];
 
   // Resolve API key
   const envKey = providerDef.envKey;
   let apiKey = process.env[envKey];
   if (!apiKey) {
-    const key = await ask(rl, chalk.cyan(`\n  ${providerDef.name} API key (${envKey}): `));
-    if (!key.trim()) {
-      console.log(chalk.yellow('\n  No API key provided. Brain not changed.\n'));
-      return config;
-    }
+    const key = await p.text({
+      message: `${providerDef.name} API key (${envKey})`,
+      validate: (v) => (!v.trim() ? 'API key is required' : undefined),
+    });
+    if (handleCancel(key)) return config;
     apiKey = key.trim();
   }
 
   // Validate the new provider before saving anything
-  console.log(chalk.dim(`\n  Verifying ${providerDef.name} / ${modelId}...`));
+  const s = p.spinner();
+  s.start(`Verifying ${providerDef.name} / ${modelId}`);
   const testConfig = { ...config, brain: { ...config.brain, provider: providerKey, model: modelId, api_key: apiKey } };
   try {
     const testProvider = createProvider(testConfig);
     await testProvider.ping();
+    s.stop(`${providerDef.name} / ${modelId} verified`);
   } catch (err) {
-    console.log(chalk.red(`\n  ✖ Verification failed: ${err.message}`));
-    console.log(chalk.yellow(`  Brain not changed. Keeping current model.\n`));
+    s.stop(chalk.red(`Verification failed: ${err.message}`));
+    p.log.warn('Brain not changed. Keeping current model.');
     return config;
   }
 
   // Validation passed — save everything
-  const savedPath = saveProviderToYaml(providerKey, modelId);
-  console.log(chalk.dim(`  Saved to ${savedPath}`));
-
+  saveProviderToYaml(providerKey, modelId);
   config.brain.provider = providerKey;
   config.brain.model = modelId;
   config.brain.api_key = apiKey;
@@ -352,10 +341,9 @@ export async function changeBrainModel(config, rl) {
   // Save the key if it was newly entered
   if (!process.env[envKey]) {
     saveCredential(config, envKey, apiKey);
-    console.log(chalk.dim('  API key saved.\n'));
   }
 
-  console.log(chalk.green(`  ✔ Brain switched to ${providerDef.name} / ${modelId}\n`));
+  p.log.success(`Brain switched to ${providerDef.name} / ${modelId}`);
   return config;
 }
 
@@ -366,9 +354,8 @@ async function promptForMissing(config) {
 
   if (missing.length === 0) return config;
 
-  console.log(chalk.yellow('\n  Missing credentials detected. Let\'s set them up.\n'));
+  p.log.warn('Missing credentials detected. Let\'s set them up.');
 
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
   const mutableConfig = JSON.parse(JSON.stringify(config));
   const envLines = [];
 
@@ -381,8 +368,11 @@ async function promptForMissing(config) {
 
   if (!mutableConfig.brain.api_key) {
     // Run brain provider selection flow
-    console.log(chalk.bold('\n  🧠 Worker Brain'));
-    const { providerKey, modelId } = await promptProviderSelection(rl);
+    p.log.step('Worker Brain');
+    const brainResult = await promptProviderSelection();
+    if (!brainResult) { p.cancel('Setup cancelled.'); process.exit(0); }
+
+    const { providerKey, modelId } = brainResult;
     mutableConfig.brain.provider = providerKey;
     mutableConfig.brain.model = modelId;
     saveProviderToYaml(providerKey, modelId);
@@ -390,36 +380,49 @@ async function promptForMissing(config) {
     const providerDef = PROVIDERS[providerKey];
     const envKey = providerDef.envKey;
 
-    const key = await ask(rl, chalk.cyan(`\n  ${providerDef.name} API key: `));
+    const key = await p.text({
+      message: `${providerDef.name} API key`,
+      validate: (v) => (!v.trim() ? 'API key is required' : undefined),
+    });
+    if (handleCancel(key)) { process.exit(0); }
     mutableConfig.brain.api_key = key.trim();
     envLines.push(`${envKey}=${key.trim()}`);
 
     // Orchestrator provider selection
-    console.log(chalk.bold('\n  🎛️  Orchestrator'));
-    const sameChoice = await ask(rl, chalk.cyan(`  Use same provider (${providerDef.name} / ${modelId}) for orchestrator? [Y/n]: `));
-    if (!sameChoice.trim() || sameChoice.trim().toLowerCase() === 'y') {
+    p.log.step('Orchestrator');
+    const sameChoice = await p.confirm({
+      message: `Use same provider (${providerDef.name} / ${modelId}) for orchestrator?`,
+      initialValue: true,
+    });
+    if (handleCancel(sameChoice)) { process.exit(0); }
+
+    if (sameChoice) {
       mutableConfig.orchestrator.provider = providerKey;
       mutableConfig.orchestrator.model = modelId;
       mutableConfig.orchestrator.api_key = key.trim();
       saveOrchestratorToYaml(providerKey, modelId);
     } else {
-      const orch = await promptProviderSelection(rl);
+      const orch = await promptProviderSelection();
+      if (!orch) { p.cancel('Setup cancelled.'); process.exit(0); }
+
       mutableConfig.orchestrator.provider = orch.providerKey;
       mutableConfig.orchestrator.model = orch.modelId;
       saveOrchestratorToYaml(orch.providerKey, orch.modelId);
 
       const orchProviderDef = PROVIDERS[orch.providerKey];
       if (orch.providerKey === providerKey) {
-        // Same provider — reuse the API key
         mutableConfig.orchestrator.api_key = key.trim();
       } else {
-        // Different provider — need a separate key
         const orchEnvKey = orchProviderDef.envKey;
         const orchExisting = process.env[orchEnvKey];
         if (orchExisting) {
           mutableConfig.orchestrator.api_key = orchExisting;
         } else {
-          const orchKey = await ask(rl, chalk.cyan(`\n  ${orchProviderDef.name} API key: `));
+          const orchKey = await p.text({
+            message: `${orchProviderDef.name} API key`,
+            validate: (v) => (!v.trim() ? 'API key is required' : undefined),
+          });
+          if (handleCancel(orchKey)) { process.exit(0); }
           mutableConfig.orchestrator.api_key = orchKey.trim();
           envLines.push(`${orchEnvKey}=${orchKey.trim()}`);
         }
@@ -428,13 +431,15 @@ async function promptForMissing(config) {
   }
 
   if (!mutableConfig.telegram.bot_token) {
-    const token = await ask(rl, chalk.cyan('  Telegram Bot Token: '));
+    const token = await p.text({
+      message: 'Telegram Bot Token',
+      validate: (v) => (!v.trim() ? 'Token is required' : undefined),
+    });
+    if (handleCancel(token)) { process.exit(0); }
     mutableConfig.telegram.bot_token = token.trim();
     envLines.push(`TELEGRAM_BOT_TOKEN=${token.trim()}`);
   }
 
-  rl.close();
-
   // Save to ~/.kernelbot/.env so it persists globally
   if (envLines.length > 0) {
     const configDir = getConfigDir();
@@ -444,9 +449,8 @@ async function promptForMissing(config) {
     // Merge with existing content
     let content = existingEnv ? existingEnv.trimEnd() + '\n' : '';
     for (const line of envLines) {
-      const key = line.split('=')[0];
-      // Replace if exists, append if not
-      const regex = new RegExp(`^${key}=.*$`, 'm');
+      const envKey = line.split('=')[0];
+      const regex = new RegExp(`^${envKey}=.*$`, 'm');
       if (regex.test(content)) {
         content = content.replace(regex, line);
       } else {
@@ -454,7 +458,7 @@ async function promptForMissing(config) {
       }
     }
     writeFileSync(savePath, content);
-    console.log(chalk.dim(`\n  Saved to ${savePath}\n`));
+    p.log.info(`Saved to ${savePath}`);
   }
 
   return mutableConfig;