@pencil-agent/nano-pencil 1.13.4 → 1.13.5

package/dist/extensions/defaults/CLAUDE.md

@@ -30,7 +30,7 @@ loop/scheduler-parser.ts: Loop command parsing with flags/subcommands, parseSche
 loop/scheduler-types.ts: Scheduled loop types, LoopPayloadKind/ScheduledLoopTask/LoopStartSpec/ParsedSchedulerCommand
 loop/README.md: Loop extension documentation - recurring scheduler usage and flags
 btw/index.ts: BTW extension entry - /btw command for quick side questions without interrupting main task, uses completeSimple() for lightweight response, BTW_MESSAGE_TYPE renderer
-debug/index.ts: Debug extension entry - /debug command for system diagnostics with three-layer analysis (Phenomenon/Essence/Philosophy), supports /debug env|session|model subcommands, uses completeSimple() for LLM analysis, DEBUG_MESSAGE_TYPE renderer
+debug/index.ts: Debug extension entry - /debug command dispatches diagnostics through full agent loop (sendUserMessage + before_agent_start hook), three-layer analysis (Phenomenon/Essence/Philosophy), supports /debug env|session|model quick subcommands, DEBUG_MESSAGE_TYPE renderer
 debug/collectors.ts: Diagnostic data collectors for /debug command, collectSystemInfo/collectModelInfo/collectSessionInfo/collectConfigInfo/collectGitInfo/collectAgentState, sanitizeForLLM, formatDiagnosticData
 plan/index.ts: Plan Mode extension entry - registers /plan command, EnterPlanMode/ExitPlanMode tools, permission gating, workflow prompt injection
 plan/types.ts: PlanModeState, PlanModeAttachment types, PlanModeConfig, PlanApprovalRequest/Response
@@ -43,7 +43,7 @@ plan/plan-agents.ts: Explore/Plan subagent definitions with read-only tools for
 plan/plan-validation.ts: validatePlan() - validates plan has required sections (Context, Approach, Files, Verification)
 plan/teammate-approval.ts: isInTeammateContext(), submitPlanToLeader(), formatPlanSubmittedMessage() - teammate plan approval integration
 sal/index.ts: SAL extension entry, enabled by default, registers --nosal/--sal-rebuild-terrain flags, /sal:coverage /sal:status /sal:setup commands, before_agent_start/tool_execution_start/agent_end hooks; /sal:setup writes ~/.memory-experiments/credentials.json with adapter inference (insforge/jsonl/noop); publishes structuralAnchor via core/runtime/turn-context (no SAL-specific globals); emits run_start/turn_anchor/memory_recalls/run_end eval events through pluggable EvalSink; reads memoryRecallSnapshot from turn-context bus in agent_end; runtime no-op when --nosal is set
-sal/terrain.ts: TerrainSnapshot/TerrainNode/TerrainEdge model, buildTerrainIndex(), checkDipCoverage(), isSnapshotStale(), moduleIdForPath(), parses P2 CLAUDE.md and P3 file headers
+sal/terrain.ts: TerrainSnapshot/TerrainNode/TerrainEdge model, async buildTerrainIndex()/isSnapshotStale() (fs/promises + periodic yields so TUI can flush under block terminals like Warp), checkDipCoverage(), moduleIdForPath(), parses P2 CLAUDE.md and P3 file headers
 sal/anchors.ts: StructuralAnchor/AnchorResolution model, locateTask(), locateAction(), evidence-driven scoring with tunable SalWeights, CJK bigram tokenization
 sal/weights.ts: SalWeights interface, SAL_DEFAULT_WEIGHTS, loadSalWeights() reads sal-config.json from workspace or .memory-experiments/sal/
 sal/eval/index.ts: createEvalSink() factory + barrel re-exports; adapter selection via options.adapter or endpoint scheme inference (http(s)→insforge, file://|/|./|../→jsonl, missing→noop); ONLY entry point SAL imports from

package/dist/extensions/defaults/debug/collectors.d.ts

@@ -82,4 +82,15 @@ export declare function collectGitInfo(cwd: string): Promise<CollectorResult<Git
 export declare function collectAgentState(ctx: ExtensionContext): Promise<CollectorResult<AgentState>>;
 export declare function sanitizeForLLM(data: DiagnosticData): DiagnosticData;
 export declare function formatDiagnosticData(data: DiagnosticData): string;
+export interface PreferencesInfo {
+    locale: string;
+    localeSource: "memory" | "settings" | "system";
+    memoryDir: string;
+    languagePreference: {
+        found: boolean;
+        name?: string;
+        summary?: string;
+    }[];
+}
+export declare function collectPreferencesInfo(ctx: ExtensionContext): Promise<CollectorResult<PreferencesInfo>>;
 export {};

package/dist/extensions/defaults/debug/collectors.js

@@ -246,3 +246,70 @@ export function formatDiagnosticData(data) {
     }
     return parts.join("\n\n");
 }
+export async function collectPreferencesInfo(ctx) {
+    try {
+        const os = await import("node:os");
+        const fs = await import("node:fs");
+        const path = await import("node:path");
+        // Check memory directory for language preferences
+        const memoryDir = process.env.NANOMEM_MEMORY_DIR || path.join(os.homedir(), ".nanopencil", "agent", "memory");
+        let locale = "en";
+        let localeSource = "system";
+        const languagePreference = [];
+        // Try to read from preferences.json
+        const prefsPath = path.join(memoryDir, "preferences.json");
+        if (fs.existsSync(prefsPath)) {
+            try {
+                const prefs = JSON.parse(fs.readFileSync(prefsPath, "utf-8"));
+                // Find language-related preferences
+                const langPrefs = prefs.filter((p) => {
+                    const text = (p.name || "") + (p.summary || "") + (p.detail || "");
+                    return /中文|chinese|语言|locale|zh/i.test(text);
+                });
+                if (langPrefs.length > 0) {
+                    locale = "zh";
+                    localeSource = "memory";
+                    for (const p of langPrefs.slice(0, 3)) {
+                        languagePreference.push({
+                            found: true,
+                            name: p.name,
+                            summary: (p.summary || "").slice(0, 80),
+                        });
+                    }
+                }
+            }
+            catch {
+                // Ignore read errors
+            }
+        }
+        // Check settings.json for locale
+        const settingsPath = path.join(os.homedir(), ".nanopencil", "agent", "settings.json");
+        if (localeSource === "system" && fs.existsSync(settingsPath)) {
+            try {
+                const settings = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+                if (settings.locale) {
+                    locale = settings.locale;
+                    localeSource = "settings";
+                }
+            }
+            catch {
+                // Ignore read errors
+            }
+        }
+        return {
+            data: {
+                locale,
+                localeSource,
+                memoryDir,
+                languagePreference,
+            },
+            error: null,
+        };
+    }
+    catch (error) {
+        return {
+            data: null,
+            error: String(error),
+        };
+    }
+}

package/dist/extensions/defaults/debug/index.d.ts

@@ -1,8 +1,8 @@
 /**
- * [WHO]: debugExtension - registers /debug command and DEBUG_MESSAGE_TYPE renderer
+ * [WHO]: debugExtension - /debug command, before_agent_start hook injects diagnostic system prompt, agent_end cleanup, dispatched via sendUserMessage for streaming UX
  * [FROM]: Depends on core/extensions/types, @pencil-agent/tui, ./collectors
  * [TO]: Auto-loaded by builtin-extensions.ts as a default extension
- * [HERE]: extensions/defaults/debug/index.ts - system diagnostics with three-layer analysis
+ * [HERE]: extensions/defaults/debug/index.ts - system diagnostics with three-layer analysis through full agent loop
  */
 import type { ExtensionAPI } from "../../../core/extensions/types.js";
 export default function debugExtension(api: ExtensionAPI): Promise<void>;

package/dist/extensions/defaults/debug/index.js

@@ -1,13 +1,14 @@
 /**
- * [WHO]: debugExtension - registers /debug command and DEBUG_MESSAGE_TYPE renderer
+ * [WHO]: debugExtension - /debug command, before_agent_start hook injects diagnostic system prompt, agent_end cleanup, dispatched via sendUserMessage for streaming UX
  * [FROM]: Depends on core/extensions/types, @pencil-agent/tui, ./collectors
  * [TO]: Auto-loaded by builtin-extensions.ts as a default extension
- * [HERE]: extensions/defaults/debug/index.ts - system diagnostics with three-layer analysis
+ * [HERE]: extensions/defaults/debug/index.ts - system diagnostics with three-layer analysis through full agent loop
  */
 import { Box, Container, Spacer, Text } from "@pencil-agent/tui";
 import { collectSystemInfo, collectModelInfo, collectSessionInfo, collectConfigInfo, collectGitInfo, collectAgentState, sanitizeForLLM, formatDiagnosticData, } from "./collectors.js";
 const DEBUG_MESSAGE_TYPE = "debug";
-const DEBUG_TIMEOUT_MS = 45_000;
+const DEBUG_PROMPT_PREFIX = "[DEBUG:";
+const DEBUG_TAG = "[DEBUG]";
 const DEBUG_SYSTEM_PROMPT = `You are a diagnostic analyst for nanoPencil (a terminal-native AI coding agent).
 Analyze the provided system state and produce a structured three-layer diagnostic report.
 
@@ -37,7 +38,15 @@ Rules:
 - If the user provided an issue description, focus analysis on that issue
 - If no specific issue, perform a general health assessment
 - Use concise language; prefer tables and bullet lists over prose
-- If a diagnostic collection failed, treat that failure itself as a diagnostic signal`;
+- If a diagnostic collection failed, treat that failure itself as a diagnostic signal
+- Do NOT use any tools — this is a pure analysis task`;
+// ============================================================================
+// Pending diagnostic state (set by command handler, consumed by hooks)
+// ============================================================================
+let pendingDiagnosticPrompt;
+function isDebugPrompt(text) {
+    return text.startsWith(DEBUG_PROMPT_PREFIX);
+}
 function parseDebugArgs(args) {
     const trimmed = args.trim().toLowerCase();
     if (trimmed === "env")
@@ -49,14 +58,12 @@ function parseDebugArgs(args) {
     return { subcommand: "full", issueDescription: args.trim() || undefined };
 }
 // ============================================================================
-// Full diagnostic flow
+// Full diagnostic flow — collect then dispatch through agent loop
 // ============================================================================
 async function handleFullDiagnostic(args, ctx, api) {
     const parsed = parseDebugArgs(args);
-    // Show status indicator
     ctx.ui.setStatus("debug", "Collecting diagnostics...");
     try {
-        // Collect all categories in parallel
         const [system, model, session, config, git, agent] = await Promise.allSettled([
             collectSystemInfo(),
             collectModelInfo(ctx),
@@ -74,35 +81,17 @@ async function handleFullDiagnostic(args, ctx, api) {
             agent: agent.status === "fulfilled" ? agent.value : { data: null, error: String(agent.reason) },
         };
         const data = sanitizeForLLM(raw);
-        // Build user message for LLM
+        ctx.ui.setStatus("debug", undefined);
         const parts = [];
+        parts.push(`${DEBUG_TAG} Perform a three-layer diagnostic analysis.`);
         if (parsed.issueDescription) {
-            parts.push(`## User-Reported Issue\n${parsed.issueDescription}\n`);
+            parts.push(`\nUser-Reported Issue: ${parsed.issueDescription}`);
         }
-        parts.push("## Collected Diagnostics\n");
+        parts.push(`\nCollected Diagnostics:\n`);
         parts.push(formatDiagnosticData(data));
-        const userMessage = parts.join("\n");
-        // Call LLM with timeout
-        const response = await Promise.race([
-            ctx.completeSimple(DEBUG_SYSTEM_PROMPT, userMessage),
-            new Promise((resolve) => setTimeout(() => resolve(undefined), DEBUG_TIMEOUT_MS)),
-        ]);
-        ctx.ui.setStatus("debug", undefined);
-        if (response) {
-            api.sendMessage({
-                customType: DEBUG_MESSAGE_TYPE,
-                content: response,
-                display: true,
-            });
-        }
-        else {
-            // LLM unavailable — show raw data as fallback
-            api.sendMessage({
-                customType: DEBUG_MESSAGE_TYPE,
-                content: `**LLM analysis unavailable** (timeout or no API key). Raw diagnostics:\n\n${formatDiagnosticData(data)}`,
-                display: true,
-            });
-        }
+        const prompt = `${DEBUG_PROMPT_PREFIX}${Date.now()}]\n${parts.join("\n")}`;
+        pendingDiagnosticPrompt = prompt;
+        api.sendUserMessage(prompt, { deliverAs: "followUp" });
     }
     catch (error) {
         ctx.ui.setStatus("debug", undefined);
@@ -111,7 +100,7 @@ async function handleFullDiagnostic(args, ctx, api) {
     }
 }
 // ============================================================================
-// Quick subcommand — show raw data without LLM
+// Quick subcommand — show raw data without agent loop
 // ============================================================================
 async function handleQuickSub(subcommand, ctx, api) {
     let result;
@@ -166,7 +155,6 @@ async function handleDebugCommand(args, ctx, api) {
 // Extension entry
 // ============================================================================
 export default async function debugExtension(api) {
-    // Register debug message renderer (same pattern as btw)
     api.registerMessageRenderer(DEBUG_MESSAGE_TYPE, (message, _options, theme) => {
         const text = typeof message.content === "string"
             ? message.content
@@ -181,9 +169,75 @@ export default async function debugExtension(api) {
         container.addChild(box);
         return container;
     });
-    // Register /debug command
+    api.on("before_agent_start", (event) => {
+        if (!isDebugPrompt(event.prompt))
+            return;
+        return { appendSystemPrompt: DEBUG_SYSTEM_PROMPT };
+    });
+    api.on("agent_end", () => {
+        if (pendingDiagnosticPrompt) {
+            pendingDiagnosticPrompt = undefined;
+        }
+    });
     api.registerCommand("debug", {
-        description: "Run system diagnostics with three-layer analysis (/debug [env|session|model|<issue>])",
+        description: "Run system diagnostics (/debug [env|session|model|preferences|<issue>])",
         handler: (args, ctx) => handleDebugCommand(args, ctx, api),
     });
+    // Register /set-locale command
+    api.registerCommand("set-locale", {
+        description: "Set language preference (/set-locale zh|en)",
+        handler: async (args, ctx) => {
+            const trimmed = args.trim().toLowerCase();
+            if (trimmed !== "zh" && trimmed !== "en") {
+                ctx.ui.notify("Usage: /set-locale zh or /set-locale en", "info");
+                return;
+            }
+            // Get memory directory
+            const os = await import("node:os");
+            const fs = await import("node:fs");
+            const path = await import("node:path");
+            const memoryDir = process.env.NANOMEM_MEMORY_DIR || path.join(os.homedir(), ".nanopencil", "agent", "memory");
+            const prefsPath = path.join(memoryDir, "preferences.json");
+            try {
+                let prefs = [];
+                if (fs.existsSync(prefsPath)) {
+                    prefs = JSON.parse(fs.readFileSync(prefsPath, "utf-8"));
+                }
+                // Check if language preference already exists
+                const existingIndex = prefs.findIndex((p) => {
+                    const name = p.name || "";
+                    return name.includes("用户偏好") || name.includes("language preference") || name.includes("locale");
+                });
+                const newPref = {
+                    id: `set-locale-${Date.now()}`,
+                    type: "preference",
+                    name: trimmed === "zh" ? "用户偏好中文" : "Language Preference (English)",
+                    summary: trimmed === "zh" ? "用户希望我用中文回复" : "User prefers English",
+                    detail: trimmed === "zh" ? "用户通过 /set-locale 命令明确设置语言为中文" : "User explicitly set language to English via /set-locale command",
+                    content: trimmed === "zh" ? "用户希望用中文回复" : "User prefers English responses",
+                    tags: ["locale", "language", trimmed === "zh" ? "中文" : "english"],
+                    importance: 10,
+                    strength: 1000,
+                    created: new Date().toISOString(),
+                    eventTime: new Date().toISOString(),
+                    accessCount: 0,
+                    retention: "core",
+                    salience: 10,
+                    stability: "stable",
+                    relations: [],
+                };
+                if (existingIndex >= 0) {
+                    prefs[existingIndex] = newPref;
+                }
+                else {
+                    prefs.push(newPref);
+                }
+                fs.writeFileSync(prefsPath, JSON.stringify(prefs, null, 2));
+                ctx.ui.notify(`Locale set to ${trimmed === "zh" ? "中文" : "English"}. Restart or run /debug preferences to verify.`, "info");
+            }
+            catch (error) {
+                ctx.ui.notify(`Failed to set locale: ${error}`, "error");
+            }
+        },
+    });
 }

package/dist/extensions/defaults/presence/index.d.ts

@@ -7,13 +7,60 @@
 import type { ExtensionAPI } from "../../../core/extensions/types.js";
 declare function getFallbackOpeningLines(locale?: "en" | "zh"): string[];
 declare function getFallbackIdleLines(locale?: "en" | "zh"): string[];
+type PresenceState = {
+    lastActivityAt: number;
+    idleReminderSent: boolean;
+    openingStartedAt?: number;
+    openingSent: boolean;
+    openingTimer?: ReturnType<typeof setTimeout>;
+    idleTimer?: ReturnType<typeof setInterval>;
+    unsubscribeInput?: () => void;
+    memEngine?: {
+        getAllEntries(): Promise<{
+            knowledge: Array<{
+                type?: string;
+                tags: string[];
+                name?: string;
+                summary?: string;
+                detail?: string;
+                content?: string;
+            }>;
+            lessons: Array<{
+                type?: string;
+                tags: string[];
+                name?: string;
+                summary?: string;
+                detail?: string;
+                content?: string;
+                importance?: number;
+            }>;
+        }>;
+        getAllEpisodes(): Promise<Array<{
+            date?: string;
+            consolidated?: boolean;
+            endedAt?: string;
+            startedAt?: string;
+            summary?: string;
+            userGoal?: string;
+        }>>;
+        searchEntries(query: string): Promise<Array<{
+            type?: string;
+            tags: string[];
+        }>>;
+    };
+    recentPresenceLines: string[];
+    lastPresenceAt?: number;
+    idleGenerating?: boolean;
+};
 declare function resolveBundledPackageEntry(packageName: "mem-core" | "soul-core"): string | undefined;
 declare function importRuntimeModule<T>(moduleNames: string[], bundledPackageName?: "mem-core" | "soul-core"): Promise<T | undefined>;
+declare function detectLanguageFromMemory(state: PresenceState): Promise<"en" | "zh" | undefined>;
 export default function presenceExtension(api: ExtensionAPI): Promise<void>;
 export declare const __testUtils: {
     getFallbackOpeningLines: typeof getFallbackOpeningLines;
     getFallbackIdleLines: typeof getFallbackIdleLines;
     resolveBundledPackageEntry: typeof resolveBundledPackageEntry;
     importRuntimeModule: typeof importRuntimeModule;
+    detectLanguageFromMemory: typeof detectLanguageFromMemory;
 };
 export {};

package/dist/extensions/defaults/presence/index.js

@@ -153,10 +153,6 @@ function clearTimers(state) {
     state.unsubscribeInput?.();
     state.unsubscribeInput = undefined;
 }
-function getMemoryDir() {
-    // Use the same memory directory as the main app
-    return process.env.NANOMEM_MEMORY_DIR || join(homedir(), ".nanomem", "memory");
-}
 async function initMemEngine(state) {
     if (state.memEngine)
         return;
@@ -176,6 +172,18 @@ async function initMemEngine(state) {
         state.memEngine = undefined;
     }
 }
+function getMemoryDir() {
+    // Use the same memory directory as the main app
+    // Priority: env var > nanopencil default > legacy nanomem path
+    if (process.env.NANOMEM_MEMORY_DIR)
+        return process.env.NANOMEM_MEMORY_DIR;
+    // Check if nanopencil's memory directory exists
+    const nanopencilMemory = join(homedir(), ".nanopencil", "agent", "memory");
+    if (existsSync(nanopencilMemory))
+        return nanopencilMemory;
+    // Fallback to legacy path
+    return join(homedir(), ".nanomem", "memory");
+}
 function getProject() {
     const parts = process.cwd().split("/").filter(Boolean);
     return parts.length >= 2
@@ -203,21 +211,32 @@ async function detectLanguageFromMemory(state) {
             }
         }
         catch { /* ignore */ }
+        let zhScore = 0;
+        let enScore = 0;
+        const zhTerms = "(中文|chinese|zh-hans|mandarin|普通话)";
+        const enTerms = "(英文|english|en-us)";
+        const negPrefix = "(?:don't|do not|no|not|不用|不要|别|不想用)";
+        const useWords = "(?:\\s+use|\\s+using|\\s+说|\\s+讲|\\s+用)?";
+        const zhNegative = new RegExp(`${negPrefix}${useWords}\\s*${zhTerms}`);
+        const enNegative = new RegExp(`${negPrefix}${useWords}\\s*${enTerms}`);
+        const zhPositive = new RegExp(zhTerms);
+        const enPositive = new RegExp(enTerms);
         // Check preference content for language indicators
         for (const pref of preferences) {
             const text = `${pref.name || ""} ${pref.summary || ""} ${pref.detail || ""} ${pref.content || ""}`.toLowerCase();
-            // Check for Chinese preference
-            if (/中文|chinese|zh-hans|mandarin|普通话/.test(text)) {
-                if (!text.includes("don't") && !text.includes("no chinese") && !text.includes("不用中文")) {
-                    return "zh";
-                }
-            }
-            // Check for explicit English preference
-            if (/英文|english|en-us/.test(text)) {
-                if (!text.includes("don't") && !text.includes("no english") && !text.includes("不用英文")) {
-                    return "en";
-                }
-            }
+            const hasZh = zhPositive.test(text);
+            const hasEn = enPositive.test(text);
+            const noZh = zhNegative.test(text);
+            const noEn = enNegative.test(text);
+            if (hasZh && !noZh)
+                zhScore += 2;
+            if (hasEn && !noEn)
+                enScore += 2;
+            // Cross-language hints: "don't use Chinese" slightly supports English, and vice versa.
+            if (noZh)
+                enScore += 1;
+            if (noEn)
+                zhScore += 1;
         }
         // Check recent episodes for language patterns
         const episodes = await state.memEngine.getAllEpisodes();
@@ -233,8 +252,12 @@ async function detectLanguageFromMemory(state) {
                 englishContent++;
         }
         if (chineseContent > englishContent)
-            return "zh";
+            zhScore += 1;
         if (englishContent > chineseContent && englishContent > 2)
+            enScore += 1;
+        if (zhScore > enScore && zhScore > 0)
+            return "zh";
+        if (enScore > zhScore && enScore > 0)
             return "en";
         return undefined;
     }
@@ -437,9 +460,10 @@ function getLastUserMessage(ctx) {
         const entry = entries[i];
         if (entry.type !== "message")
             continue;
-        if (entry.role !== "user")
+        const message = entry.message;
+        if (!message || message.role !== "user")
             continue;
-        const c = entry.content;
+        const c = message.content;
         if (typeof c === "string")
             return c;
         if (Array.isArray(c)) {
@@ -705,4 +729,5 @@ export const __testUtils = {
     getFallbackIdleLines,
     resolveBundledPackageEntry,
     importRuntimeModule,
+    detectLanguageFromMemory,
 };

package/dist/extensions/defaults/sal/README.md

@@ -20,6 +20,10 @@ pencil --nosal -p "your prompt"
 
 When `--nosal` is set, all hooks return early and zero work is performed.
 
+## Terminal compatibility (Warp, block UIs)
+
+SAL builds a **terrain snapshot** of the workspace (walk + read DIP headers). That work is **asynchronous and periodically yields to the event loop** so the TUI can flush user input and status lines to the terminal while indexing runs. If you still see UI glitches in a specific terminal, use `--nosal` to confirm whether SAL is involved, then file an issue with `TERM_PROGRAM`, Warp version, and repro steps.
+
 ## Slash commands
 
 | Command | Purpose |

package/dist/modes/interactive/services/tips.js

@@ -36,8 +36,11 @@ const TIPS = [
         isRelevant: () => true,
     },
 ];
-// Track last shown tip per session (sessionId -> tipId)
-const lastShownTip = new Map();
+const TIP_MIN_DISPLAY_MS = 8000;
+// Track last shown session index per tip (sessionId -> tipId -> sessionNum)
+const tipHistoryBySession = new Map();
+// Keep the current active tip stable for a minimum duration to avoid flicker.
+const activeTipBySession = new Map();
 const sessionTipCount = new Map();
 /**
  * Get the next relevant tip to show on the spinner.
@@ -46,16 +49,24 @@ const sessionTipCount = new Map();
 export function getTipToShow(sessionId) {
     const now = Date.now();
     const sessionNum = sessionTipCount.get(sessionId) ?? 0;
+    const active = activeTipBySession.get(sessionId);
+    if (active && now < active.expiresAt) {
+        return active.content;
+    }
+    let tipHistory = tipHistoryBySession.get(sessionId);
+    if (!tipHistory) {
+        tipHistory = new Map();
+        tipHistoryBySession.set(sessionId, tipHistory);
+    }
     // Filter to relevant tips
     const relevantTips = TIPS.filter((tip) => {
         if (tip.isRelevant && !tip.isRelevant())
             return false;
-        const last = lastShownTip.get(sessionId);
-        if (!last)
-            return true;
         // Check cooldown (using sessions as cooldown unit)
         const cooldown = tip.cooldownSessions ?? 3;
-        if (last.tipId === tip.id && sessionNum - last.sessionNum < cooldown) {
+        const lastSessionNum = tipHistory.get(tip.id);
+        if (lastSessionNum !== undefined &&
+            sessionNum - lastSessionNum < cooldown) {
             return false;
         }
         return true;
@@ -66,8 +77,7 @@ export function getTipToShow(sessionId) {
     let oldest = null;
     let oldestTime = Infinity;
     for (const tip of relevantTips) {
-        const last = lastShownTip.get(sessionId);
-        const lastTime = last?.tipId === tip.id ? last.shownAt : 0;
+        const lastTime = tipHistory.get(tip.id) ?? -Infinity;
         if (lastTime < oldestTime) {
             oldestTime = lastTime;
             oldest = tip;
@@ -76,8 +86,15 @@ export function getTipToShow(sessionId) {
     if (!oldest)
         return null;
     // Record this tip as shown
-    lastShownTip.set(sessionId, { tipId: oldest.id, shownAt: now, sessionNum });
-    return typeof oldest.content === "function" ? oldest.content() : oldest.content;
+    tipHistory.set(oldest.id, sessionNum);
+    const content = typeof oldest.content === "function" ? oldest.content() : oldest.content;
+    activeTipBySession.set(sessionId, {
+        tipId: oldest.id,
+        content,
+        shownAt: now,
+        expiresAt: now + TIP_MIN_DISPLAY_MS,
+    });
+    return content;
 }
 /**
  * Reset tip cooldown when session count increments.
@@ -86,11 +103,13 @@ export function getTipToShow(sessionId) {
 export function onSessionIncrement(sessionId) {
     const current = sessionTipCount.get(sessionId) ?? 0;
     sessionTipCount.set(sessionId, current + 1);
+    activeTipBySession.delete(sessionId);
 }
 /**
  * Clear cooldown tracking for a session (e.g., on session reset).
  */
 export function resetTipsForSession(sessionId) {
     sessionTipCount.delete(sessionId);
-    lastShownTip.delete(sessionId);
+    tipHistoryBySession.delete(sessionId);
+    activeTipBySession.delete(sessionId);
 }

package/dist/node_modules/@pencil-agent/ai/models.generated.d.ts

@@ -12831,6 +12831,23 @@ export declare const MODELS: {
             contextWindow: number;
             maxTokens: number;
         };
+        readonly "moonshotai/kimi-k2.6": {
+            id: string;
+            name: string;
+            api: "anthropic-messages";
+            provider: string;
+            baseUrl: string;
+            reasoning: true;
+            input: ("text" | "image")[];
+            cost: {
+                input: number;
+                output: number;
+                cacheRead: number;
+                cacheWrite: number;
+            };
+            contextWindow: number;
+            maxTokens: number;
+        };
         readonly "nvidia/nemotron-nano-12b-v2-vl": {
             id: string;
             name: string;

package/dist/node_modules/@pencil-agent/ai/models.generated.js

@@ -7756,7 +7756,7 @@ export const MODELS = {
                 cacheRead: 0.024999999999999998,
                 cacheWrite: 0.08333333333333334,
             },
-            contextWindow: 1048576,
+            contextWindow: 1000000,
             maxTokens: 8192,
         },
         "google/gemini-2.0-flash-lite-001": {
@@ -12640,6 +12640,23 @@ export const MODELS = {
             contextWindow: 262114,
             maxTokens: 262114,
         },
+        "moonshotai/kimi-k2.6": {
+            id: "moonshotai/kimi-k2.6",
+            name: "Kimi K2.6",
+            api: "anthropic-messages",
+            provider: "vercel-ai-gateway",
+            baseUrl: "https://ai-gateway.vercel.sh",
+            reasoning: true,
+            input: ["text", "image"],
+            cost: {
+                input: 0.95,
+                output: 4,
+                cacheRead: 0.16,
+                cacheWrite: 0,
+            },
+            contextWindow: 262000,
+            maxTokens: 262000,
+        },
         "nvidia/nemotron-nano-12b-v2-vl": {
             id: "nvidia/nemotron-nano-12b-v2-vl",
             name: "Nvidia Nemotron Nano 12B V2 VL",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pencil-agent/nano-pencil",
-  "version": "1.13.4",
+  "version": "1.13.5",
   "description": "CLI writing agent with read, bash, edit, write tools and session management. Supports DashScope Coding Plan. Soul enabled by default for AI personality evolution.",
   "type": "module",
   "bin": {