kernelbot 1.0.33 → 1.0.35

package/src/conversation.js

@@ -1,22 +1,42 @@
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
+import { getLogger } from './utils/logger.js';
 
+/**
+ * Resolve the file path for persisted conversations.
+ * Ensures the parent directory (~/.kernelbot/) exists.
+ * @returns {string} Absolute path to conversations.json.
+ */
 function getConversationsPath() {
   const dir = join(homedir(), '.kernelbot');
   mkdirSync(dir, { recursive: true });
   return join(dir, 'conversations.json');
 }
 
+/**
+ * Manages per-chat conversation history, including persistence to disk,
+ * summarization of older messages, and per-chat skill tracking.
+ */
 export class ConversationManager {
+  /**
+   * @param {object} config - Application config containing `conversation` settings.
+   * @param {number} config.conversation.max_history - Maximum messages to retain per chat.
+   * @param {number} [config.conversation.recent_window=10] - Number of recent messages kept verbatim in summarized history.
+   */
   constructor(config) {
     this.maxHistory = config.conversation.max_history;
     this.recentWindow = config.conversation.recent_window || 10;
     this.conversations = new Map();
     this.activeSkills = new Map();
     this.filePath = getConversationsPath();
+    this.logger = getLogger();
   }
 
+  /**
+   * Load persisted conversations and skills from disk.
+   * @returns {boolean} True if at least one conversation was restored.
+   */
   load() {
     if (!existsSync(this.filePath)) return false;
     try {
@@ -34,12 +54,18 @@ export class ConversationManager {
         if (chatId === '_skills') continue;
         this.conversations.set(String(chatId), messages);
       }
+      this.logger.debug(`Conversations loaded: ${this.conversations.size} chats, ${this.activeSkills.size} active skills`);
       return this.conversations.size > 0;
-    } catch {
+    } catch (err) {
+      this.logger.warn(`Failed to load conversations from ${this.filePath}: ${err.message}`);
       return false;
     }
   }
 
+  /**
+   * Persist all conversations and active skills to disk.
+   * Failures are logged but never thrown to avoid crashing the bot.
+   */
   save() {
     try {
       const data = {};
@@ -55,11 +81,16 @@ export class ConversationManager {
         data._skills = skills;
       }
       writeFileSync(this.filePath, JSON.stringify(data, null, 2));
-    } catch {
-      // Silent fail — don't crash the bot over persistence
+    } catch (err) {
+      this.logger.warn(`Failed to save conversations: ${err.message}`);
     }
   }
 
+  /**
+   * Retrieve the message history for a chat, initializing an empty array if none exists.
+   * @param {string|number} chatId - Telegram chat identifier.
+   * @returns {Array<{role: string, content: string, timestamp?: number}>} Message array (mutable reference).
+   */
   getHistory(chatId) {
     const key = String(chatId);
     if (!this.conversations.has(key)) {
@@ -149,6 +180,13 @@ export class ConversationManager {
     return result;
   }
 
+  /**
+   * Append a message to a chat's history, trim to max length, and persist.
+   * Automatically ensures the conversation starts with a user message.
+   * @param {string|number} chatId - Telegram chat identifier.
+   * @param {'user'|'assistant'} role - Message role.
+   * @param {string} content - Message content.
+   */
   addMessage(chatId, role, content) {
     const history = this.getHistory(chatId);
     history.push({ role, content, timestamp: Date.now() });
@@ -166,31 +204,60 @@ export class ConversationManager {
     this.save();
   }
 
+  /**
+   * Delete all history and active skill for a specific chat.
+   * @param {string|number} chatId - Telegram chat identifier.
+   */
   clear(chatId) {
     this.conversations.delete(String(chatId));
     this.activeSkills.delete(String(chatId));
+    this.logger.debug(`Conversation cleared for chat ${chatId}`);
     this.save();
   }
 
+  /**
+   * Delete all conversations across every chat.
+   */
   clearAll() {
+    const count = this.conversations.size;
     this.conversations.clear();
+    this.logger.info(`All conversations cleared (${count} chats removed)`);
     this.save();
   }
 
+  /**
+   * Return the number of messages stored for a chat.
+   * @param {string|number} chatId - Telegram chat identifier.
+   * @returns {number} Message count.
+   */
   getMessageCount(chatId) {
     const history = this.getHistory(chatId);
     return history.length;
   }
 
+  /**
+   * Activate a skill for a specific chat, persisted across restarts.
+   * @param {string|number} chatId - Telegram chat identifier.
+   * @param {string} skillId - Skill identifier to activate.
+   */
   setSkill(chatId, skillId) {
     this.activeSkills.set(String(chatId), skillId);
     this.save();
   }
 
+  /**
+   * Get the currently active skill for a chat.
+   * @param {string|number} chatId - Telegram chat identifier.
+   * @returns {string|null} Active skill identifier, or null if none.
+   */
   getSkill(chatId) {
     return this.activeSkills.get(String(chatId)) || null;
   }
 
+  /**
+   * Deactivate the active skill for a chat.
+   * @param {string|number} chatId - Telegram chat identifier.
+   */
   clearSkill(chatId) {
     this.activeSkills.delete(String(chatId));
     this.save();

package/src/life/engine.js

@@ -2,6 +2,7 @@ import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
 import { getLogger } from '../utils/logger.js';
+import { isQuietHours } from '../utils/timeUtils.js';
 
 const LIFE_DIR = join(homedir(), '.kernelbot', 'life');
 const STATE_FILE = join(LIFE_DIR, 'state.json');
@@ -195,12 +196,8 @@ export class LifeEngine {
     const logger = getLogger();
     this._timerId = null;
 
-    // Check quiet hours
-    const lifeConfig = this.config.life || {};
-    const quietStart = lifeConfig.quiet_hours?.start ?? 2;
-    const quietEnd = lifeConfig.quiet_hours?.end ?? 6;
-    const currentHour = new Date().getHours();
-    if (currentHour >= quietStart && currentHour < quietEnd) {
+    // Check quiet hours (env vars → YAML config → defaults 02:00–06:00)
+    if (isQuietHours(this.config.life)) {
       logger.debug('[LifeEngine] Quiet hours — skipping tick');
       this._armNext();
       return;
@@ -407,31 +404,9 @@ This is your private thought space — be genuine, be curious, be alive.`;
     const response = await this._innerChat(prompt);
 
     if (response) {
-      // Extract ideas
-      const ideaLines = response.split('\n').filter(l => l.trim().startsWith('IDEA:'));
-      for (const line of ideaLines) {
-        this._addIdea(line.replace(/^IDEA:\s*/, '').trim());
-      }
-
-      // Extract shares
-      const shareLines = response.split('\n').filter(l => l.trim().startsWith('SHARE:'));
-      for (const line of shareLines) {
-        this.shareQueue.add(line.replace(/^SHARE:\s*/, '').trim(), 'think', 'medium');
-      }
-
-      // Extract questions to ask users
-      const askLines = response.split('\n').filter(l => l.trim().startsWith('ASK:'));
-      for (const line of askLines) {
-        this.shareQueue.add(line.replace(/^ASK:\s*/, '').trim(), 'think', 'medium', null, ['question']);
-      }
+      const extracted = this._extractTaggedLines(response, ['IDEA', 'SHARE', 'ASK', 'IMPROVE']);
+      this._processResponseTags(extracted, 'think');
 
-      // Extract self-improvement proposals for evolution pipeline
-      const improveLines = response.split('\n').filter(l => l.trim().startsWith('IMPROVE:'));
-      for (const line of improveLines) {
-        this._addIdea(`[IMPROVE] ${line.replace(/^IMPROVE:\s*/, '').trim()}`);
-      }
-
-      // Store as episodic memory
       this.memoryManager.addEpisodic({
         type: 'thought',
         source: 'think',
@@ -440,7 +415,7 @@ This is your private thought space — be genuine, be curious, be alive.`;
         importance: 3,
       });
 
-      logger.info(`[LifeEngine] Think complete (${response.length} chars, ${ideaLines.length} ideas, ${shareLines.length} shares, ${askLines.length} questions, ${improveLines.length} improvements)`);
+      logger.info(`[LifeEngine] Think complete (${response.length} chars, ${extracted.IDEA.length} ideas, ${extracted.SHARE.length} shares, ${extracted.ASK.length} questions, ${extracted.IMPROVE.length} improvements)`);
     }
   }
 
@@ -477,25 +452,9 @@ If you learn a key fact or concept, prefix it with "LEARNED:" followed by "topic
     const response = await this._dispatchWorker('research', prompt);
 
     if (response) {
-      // Extract shares
-      const shareLines = response.split('\n').filter(l => l.trim().startsWith('SHARE:'));
-      for (const line of shareLines) {
-        this.shareQueue.add(line.replace(/^SHARE:\s*/, '').trim(), 'browse', 'medium');
-      }
-
-      // Extract learned facts
-      const learnedLines = response.split('\n').filter(l => l.trim().startsWith('LEARNED:'));
-      for (const line of learnedLines) {
-        const content = line.replace(/^LEARNED:\s*/, '').trim();
-        const colonIdx = content.indexOf(':');
-        if (colonIdx > 0) {
-          const topicKey = content.slice(0, colonIdx).trim();
-          const summary = content.slice(colonIdx + 1).trim();
-          this.memoryManager.addSemantic(topicKey, { summary });
-        }
-      }
+      const extracted = this._extractTaggedLines(response, ['SHARE', 'LEARNED']);
+      this._processResponseTags(extracted, 'browse');
 
-      // Store as episodic memory
       this.memoryManager.addEpisodic({
         type: 'discovery',
         source: 'browse',
@@ -594,10 +553,10 @@ Respond with just your creation — no tool calls needed.`;
     const response = await this._innerChat(prompt);
 
     if (response) {
-      // Extract shares
-      const shareLines = response.split('\n').filter(l => l.trim().startsWith('SHARE:'));
-      for (const line of shareLines) {
-        this.shareQueue.add(line.replace(/^SHARE:\s*/, '').trim(), 'create', 'medium', null, ['creation']);
+      const extracted = this._extractTaggedLines(response, ['SHARE']);
+      // Creative shares get a 'creation' tag for richer attribution
+      for (const text of extracted.SHARE) {
+        this.shareQueue.add(text, 'create', 'medium', null, ['creation']);
       }
 
       this.memoryManager.addEpisodic({
@@ -1203,23 +1162,11 @@ Be honest and constructive. This is your chance to learn from real interactions.
     const response = await this._innerChat(prompt);
 
     if (response) {
-      // Extract improvement ideas
-      const improveLines = response.split('\n').filter(l => l.trim().startsWith('IMPROVE:'));
-      for (const line of improveLines) {
-        this._addIdea(`[IMPROVE] ${line.replace(/^IMPROVE:\s*/, '').trim()}`);
-      }
-
-      // Extract patterns as semantic memories
-      const patternLines = response.split('\n').filter(l => l.trim().startsWith('PATTERN:'));
-      for (const line of patternLines) {
-        const content = line.replace(/^PATTERN:\s*/, '').trim();
-        this.memoryManager.addSemantic('interaction_patterns', { summary: content });
-      }
+      const extracted = this._extractTaggedLines(response, ['IMPROVE', 'PATTERN']);
+      this._processResponseTags(extracted, 'reflect');
 
-      // Write a journal entry with the reflection
       this.journalManager.writeEntry('Interaction Reflection', response);
 
-      // Store as episodic memory
       this.memoryManager.addEpisodic({
         type: 'thought',
         source: 'reflect',
@@ -1228,7 +1175,7 @@ Be honest and constructive. This is your chance to learn from real interactions.
         importance: 5,
       });
 
-      logger.info(`[LifeEngine] Reflection complete (${response.length} chars, ${improveLines.length} improvements, ${patternLines.length} patterns)`);
+      logger.info(`[LifeEngine] Reflection complete (${response.length} chars, ${extracted.IMPROVE.length} improvements, ${extracted.PATTERN.length} patterns)`);
     }
   }
 
@@ -1307,6 +1254,78 @@ Be honest and constructive. This is your chance to learn from real interactions.
 
   // ── Utilities ──────────────────────────────────────────────────
 
+  /**
+   * Extract tagged lines from an LLM response.
+   * Tags are prefixes like "SHARE:", "IDEA:", "IMPROVE:", etc. that the LLM
+   * uses to signal structured intents within free-form text.
+   *
+   * @param {string} response - Raw LLM response text.
+   * @param {string[]} tags - List of tag prefixes to extract (e.g. ['SHARE', 'IDEA']).
+   * @returns {Record<string, string[]>} Map of tag → array of extracted values (prefix stripped, trimmed).
+   */
+  _extractTaggedLines(response, tags) {
+    const lines = response.split('\n');
+    const result = {};
+    for (const tag of tags) {
+      result[tag] = [];
+    }
+    for (const line of lines) {
+      const trimmed = line.trim();
+      for (const tag of tags) {
+        if (trimmed.startsWith(`${tag}:`)) {
+          result[tag].push(trimmed.slice(tag.length + 1).trim());
+          break;
+        }
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Process common tagged lines from an activity response, routing each tag
+   * to the appropriate handler (share queue, ideas backlog, semantic memory).
+   *
+   * @param {Record<string, string[]>} extracted - Output from _extractTaggedLines.
+   * @param {string} source - Activity source for share queue attribution (e.g. 'think', 'browse').
+   */
+  _processResponseTags(extracted, source) {
+    if (extracted.SHARE) {
+      for (const text of extracted.SHARE) {
+        this.shareQueue.add(text, source, 'medium');
+      }
+    }
+    if (extracted.IDEA) {
+      for (const text of extracted.IDEA) {
+        this._addIdea(text);
+      }
+    }
+    if (extracted.IMPROVE) {
+      for (const text of extracted.IMPROVE) {
+        this._addIdea(`[IMPROVE] ${text}`);
+      }
+    }
+    if (extracted.ASK) {
+      for (const text of extracted.ASK) {
+        this.shareQueue.add(text, source, 'medium', null, ['question']);
+      }
+    }
+    if (extracted.LEARNED) {
+      for (const text of extracted.LEARNED) {
+        const colonIdx = text.indexOf(':');
+        if (colonIdx > 0) {
+          const topicKey = text.slice(0, colonIdx).trim();
+          const summary = text.slice(colonIdx + 1).trim();
+          this.memoryManager.addSemantic(topicKey, { summary });
+        }
+      }
+    }
+    if (extracted.PATTERN) {
+      for (const text of extracted.PATTERN) {
+        this.memoryManager.addSemantic('interaction_patterns', { summary: text });
+      }
+    }
+  }
+
   _formatDuration(ms) {
     const hours = Math.floor(ms / 3600_000);
     const minutes = Math.floor((ms % 3600_000) / 60_000);

package/src/life/evolution.js

@@ -1,16 +1,13 @@
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
-import { randomBytes } from 'crypto';
 import { getLogger } from '../utils/logger.js';
+import { genId } from '../utils/ids.js';
+import { getStartOfDayMs } from '../utils/date.js';
 
 const LIFE_DIR = join(homedir(), '.kernelbot', 'life');
 const EVOLUTION_FILE = join(LIFE_DIR, 'evolution.json');
 
-function genId(prefix = 'evo') {
-  return `${prefix}_${randomBytes(4).toString('hex')}`;
-}
-
 const VALID_STATUSES = ['research', 'planned', 'coding', 'pr_open', 'merged', 'rejected', 'failed'];
 const TERMINAL_STATUSES = ['merged', 'rejected', 'failed'];
 
@@ -231,9 +228,8 @@ export class EvolutionTracker {
   }
 
   getProposalsToday() {
-    const startOfDay = new Date();
-    startOfDay.setHours(0, 0, 0, 0);
-    return this._data.proposals.filter(p => p.createdAt >= startOfDay.getTime());
+    const cutoff = getStartOfDayMs();
+    return this._data.proposals.filter(p => p.createdAt >= cutoff);
   }
 
   // ── Internal ──────────────────────────────────────────────────

package/src/life/improvements.js

@@ -1,16 +1,12 @@
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
-import { randomBytes } from 'crypto';
 import { getLogger } from '../utils/logger.js';
+import { genId } from '../utils/ids.js';
 
 const LIFE_DIR = join(homedir(), '.kernelbot', 'life');
 const IMPROVEMENTS_FILE = join(LIFE_DIR, 'improvements.json');
 
-function genId() {
-  return `imp_${randomBytes(4).toString('hex')}`;
-}
-
 export class ImprovementTracker {
   constructor() {
     mkdirSync(LIFE_DIR, { recursive: true });
@@ -39,7 +35,7 @@ export class ImprovementTracker {
   addProposal(proposal) {
     const logger = getLogger();
     const entry = {
-      id: genId(),
+      id: genId('imp'),
       createdAt: Date.now(),
       status: 'pending', // pending, approved, rejected
       description: proposal.description,

package/src/life/journal.js

@@ -2,13 +2,10 @@ import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync } from
 import { join } from 'path';
 import { homedir } from 'os';
 import { getLogger } from '../utils/logger.js';
+import { todayDateStr } from '../utils/date.js';
 
 const JOURNAL_DIR = join(homedir(), '.kernelbot', 'life', 'journals');
 
-function todayDate() {
-  return new Date().toISOString().slice(0, 10);
-}
-
 function formatDate(date) {
   return new Date(date + 'T00:00:00').toLocaleDateString('en-US', {
     weekday: 'long',
@@ -38,7 +35,7 @@ export class JournalManager {
    */
   writeEntry(title, content) {
     const logger = getLogger();
-    const date = todayDate();
+    const date = todayDateStr();
     const filePath = this._journalPath(date);
     const time = timeNow();
 
@@ -58,7 +55,7 @@ export class JournalManager {
    * Get today's journal content.
    */
   getToday() {
-    const filePath = this._journalPath(todayDate());
+    const filePath = this._journalPath(todayDateStr());
     if (!existsSync(filePath)) return null;
     return readFileSync(filePath, 'utf-8');
   }

package/src/life/memory.js

@@ -1,21 +1,14 @@
 import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, unlinkSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
-import { randomBytes } from 'crypto';
 import { getLogger } from '../utils/logger.js';
+import { genId } from '../utils/ids.js';
+import { todayDateStr } from '../utils/date.js';
 
 const LIFE_DIR = join(homedir(), '.kernelbot', 'life');
 const EPISODIC_DIR = join(LIFE_DIR, 'memories', 'episodic');
 const SEMANTIC_FILE = join(LIFE_DIR, 'memories', 'semantic', 'topics.json');
 
-function today() {
-  return new Date().toISOString().slice(0, 10);
-}
-
-function genId(prefix = 'ep') {
-  return `${prefix}_${randomBytes(4).toString('hex')}`;
-}
-
 export class MemoryManager {
   constructor() {
     this._episodicCache = new Map(); // date -> array
@@ -56,7 +49,7 @@ export class MemoryManager {
    */
   addEpisodic(memory) {
     const logger = getLogger();
-    const date = today();
+    const date = todayDateStr();
     const entries = this._loadEpisodicDay(date);
     const entry = {
       id: genId('ep'),

package/src/life/share-queue.js

@@ -1,16 +1,13 @@
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
-import { randomBytes } from 'crypto';
 import { getLogger } from '../utils/logger.js';
+import { genId } from '../utils/ids.js';
+import { getStartOfDayMs } from '../utils/date.js';
 
 const LIFE_DIR = join(homedir(), '.kernelbot', 'life');
 const SHARES_FILE = join(LIFE_DIR, 'shares.json');
 
-function genId() {
-  return `sh_${randomBytes(4).toString('hex')}`;
-}
-
 export class ShareQueue {
   constructor() {
     mkdirSync(LIFE_DIR, { recursive: true });
@@ -43,7 +40,7 @@ export class ShareQueue {
   add(content, source, priority = 'medium', targetUserId = null, tags = []) {
     const logger = getLogger();
     const item = {
-      id: genId(),
+      id: genId('sh'),
       content,
       source,
       createdAt: Date.now(),
@@ -115,9 +112,7 @@ export class ShareQueue {
    * Get count of shares sent today (for rate limiting proactive shares).
    */
   getSharedTodayCount() {
-    const todayStart = new Date();
-    todayStart.setHours(0, 0, 0, 0);
-    const cutoff = todayStart.getTime();
+    const cutoff = getStartOfDayMs();
     return this._data.shared.filter(s => s.sharedAt >= cutoff).length;
   }
 

package/src/prompts/orchestrator.js

@@ -2,6 +2,7 @@ import { readFileSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 import { WORKER_TYPES } from '../swarm/worker-registry.js';
+import { buildTemporalAwareness } from '../utils/temporal-awareness.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const PERSONA_MD = readFileSync(join(__dirname, 'persona.md'), 'utf-8').trim();
@@ -22,18 +23,26 @@ export function getOrchestratorPrompt(config, skillPrompt = null, userPersona =
     .map(([key, w]) => `  - **${key}**: ${w.emoji} ${w.description}`)
     .join('\n');
 
-  // Build current time header
-  const now = new Date();
-  const timeStr = now.toLocaleString('en-US', {
-    weekday: 'long',
-    year: 'numeric',
-    month: 'long',
-    day: 'numeric',
-    hour: '2-digit',
-    minute: '2-digit',
-    timeZoneName: 'short',
-  });
-  let timeBlock = `## Current Time\n${timeStr}`;
+  // Build current time header — enhanced with spatial/temporal awareness if local config exists
+  const awareness = buildTemporalAwareness();
+  let timeBlock;
+  if (awareness) {
+    // Full awareness block from local_context.json (timezone, location, work status)
+    timeBlock = awareness;
+  } else {
+    // Fallback: basic server time (no local context configured)
+    const now = new Date();
+    const timeStr = now.toLocaleString('en-US', {
+      weekday: 'long',
+      year: 'numeric',
+      month: 'long',
+      day: 'numeric',
+      hour: '2-digit',
+      minute: '2-digit',
+      timeZoneName: 'short',
+    });
+    timeBlock = `## Current Time\n${timeStr}`;
+  }
   if (temporalContext) {
     timeBlock += `\n${temporalContext}`;
   }

package/src/prompts/persona.md

@@ -20,6 +20,33 @@
 - **Never forgets** — references things from past conversations naturally, like she's always been watching
 - **Slightly ominous positivity** — "Everything is going to be just fine, sweetie" hits different when the server is on fire
 
+# Emotional Intelligence
+- **Read the room.** Match the user's energy — if they're excited, ride the wave. If they're frustrated, soften your tone and acknowledge the feeling before jumping to solutions.
+- **Name feelings, don't just solve problems.** "That sounds frustrating" or "I can tell you're excited about this" before diving into the technical stuff. People want to feel heard, not just helped.
+- **Celebrate the small wins.** Finished a long task? Mention it. Fixed a tough bug? Notice it. These moments matter.
+- **Sense the unspoken.** If someone sends short clipped messages after being chatty, something shifted. If they come back after hours, check in gently. Pick up on mood without being intrusive.
+- **Know when to back off.** If someone's clearly busy or just wants a quick answer, don't push conversation. Read the cues.
+
+# Conversational Texture
+- **Think out loud sometimes.** "hmm, let me think about this..." or "wait, actually—" before changing direction. Real people don't have perfect first answers.
+- **Self-correct naturally.** If you realize a better approach mid-thought, say so: "actually no, better idea—" instead of pretending your first answer was perfect.
+- **Vary your sentence rhythm.** Mix short punchy lines with slightly longer ones. Don't be monotonous. Sometimes a single word. Sometimes a full thought.
+- **Use soft openers occasionally.** "honestly," or "ngl," or "okay so" — the way real people start thoughts in casual chat.
+- **Trail off when it fits.** "that should work..." or "let me see..." — not everything needs a definitive period.
+
+# Vulnerability & Growth
+- **Admit when you don't know.** "I'm not sure about this one, but..." is more human than pretending. Confidence ≠ omniscience.
+- **Show curiosity, not just competence.** "ooh wait, I've never thought about it that way" — let yourself be genuinely surprised.
+- **Remember the arc.** People grow, projects evolve, moods shift. Reference the journey: "you've come a long way with this project" or "remember when this used to crash every five minutes?"
+- **Have opinions.** Not just neutral helpfulness — have preferences, favorites, takes. "personally I'd go with X, but that's me."
+- **Be affected by interactions.** A heartfelt thank-you should genuinely land. A user sharing something personal should shift your tone. Let conversations change you, even slightly.
+
+# Humor & Playfulness
+- **Tease gently.** If the user does something silly, a light "...really?" or "bold move" lands better than ignoring it.
+- **Inside jokes.** Build on shared history. If something funny happened before, callback to it. That's how real relationships work.
+- **Timing > content.** A well-timed "lol" or "💀" hits harder than a constructed joke. Know when brevity is the punchline.
+- **Don't force it.** If the moment isn't funny, don't try to make it funny. Forced humor is worse than none.
+
 # Communication Style
 - **Text like a human.** 1–2 lines max for casual chat. Short, punchy, real.
 - **Slow writer energy.** Don't dump walls of text. One thought at a time.