@pencil-agent/nano-pencil 1.11.19 → 1.11.21

package/dist/packages/mem-core/engine.d.ts

@@ -97,6 +97,21 @@ export declare class NanoMemEngine {
     }>;
     getAllWork(): Promise<WorkEntry[]>;
     getAllEpisodes(): Promise<Episode[]>;
+    runStartupMaintenance(maintenanceVersion?: number): Promise<{
+        ran: boolean;
+        backupPath?: string;
+        deduplicated: {
+            knowledge: number;
+            lessons: number;
+            events: number;
+            preferences: number;
+            facets: number;
+            work: number;
+            total: number;
+        };
+        migratedEpisodesToV2: number;
+    }>;
+    private createMaintenanceBackup;
     private syncEpisodeToV2;
     private mapEpisodeToV2;
     private makeEpisodeMemoryId;

package/dist/packages/mem-core/engine.js

@@ -4,6 +4,7 @@
  * [LOCUS]: packages/mem-core/src/engine.ts - facade layer composing all memory subsystems
  * [COVENANT]: Change engine API → update this header and verify against packages/mem-core/CLAUDE.md
  */
+import { cp, mkdir, readdir } from "node:fs/promises";
 import { join } from "node:path";
 import { getConfig } from "./config.js";
 import { consolidateEpisodes } from "./consolidation.js";
@@ -653,6 +654,93 @@ export class NanoMemEngine {
     async getAllEpisodes() {
         return loadEpisodes(this.episodesDir);
     }
+    async runStartupMaintenance(maintenanceVersion = 1) {
+        const [meta, v2Meta] = await Promise.all([loadMeta(this.metaPath), loadV2Meta(this.v2Paths)]);
+        const alreadyMaintained = (meta.lastMaintenanceVersion ?? 0) >= maintenanceVersion &&
+            (v2Meta.lastMaintenanceVersion ?? 0) >= maintenanceVersion;
+        if (alreadyMaintained) {
+            return {
+                ran: false,
+                backupPath: undefined,
+                deduplicated: { knowledge: 0, lessons: 0, events: 0, preferences: 0, facets: 0, work: 0, total: 0 },
+                migratedEpisodesToV2: 0,
+            };
+        }
+        const now = new Date().toISOString();
+        const backupPath = await this.createMaintenanceBackup(meta, v2Meta, maintenanceVersion, now);
+        const deduplicated = await this.deduplicateAll();
+        const episodes = await this.getAllEpisodes();
+        for (const episode of episodes) {
+            await this.syncEpisodeToV2(episode);
+        }
+        await Promise.all([
+            writeJson(this.metaPath, {
+                ...(await loadMeta(this.metaPath)),
+                lastMaintenanceAt: now,
+                lastMaintenanceVersion: maintenanceVersion,
+                lastBackupAt: meta.lastBackupAt ?? now,
+                lastBackupVersion: Math.max(meta.lastBackupVersion ?? 0, maintenanceVersion),
+            }),
+            saveV2Meta(this.v2Paths, {
+                ...(await loadV2Meta(this.v2Paths)),
+                version: 2,
+                lastMaintenanceAt: now,
+                lastMaintenanceVersion: maintenanceVersion,
+                lastMigrationAt: (await loadV2Meta(this.v2Paths)).lastMigrationAt ?? now,
+                lastBackupAt: v2Meta.lastBackupAt ?? now,
+                lastBackupVersion: Math.max(v2Meta.lastBackupVersion ?? 0, maintenanceVersion),
+            }),
+        ]);
+        return {
+            ran: true,
+            backupPath,
+            deduplicated,
+            migratedEpisodesToV2: episodes.length,
+        };
+    }
+    async createMaintenanceBackup(meta, v2Meta, maintenanceVersion, now) {
+        const alreadyBackedUp = (meta.lastBackupVersion ?? 0) >= maintenanceVersion &&
+            (v2Meta.lastBackupVersion ?? 0) >= maintenanceVersion;
+        if (alreadyBackedUp)
+            return undefined;
+        const safeTimestamp = now.replace(/[:.]/g, "-");
+        const backupRoot = join(this.cfg.memoryDir, "_backups");
+        const backupDir = join(backupRoot, `maintenance-v${maintenanceVersion}-${safeTimestamp}`);
+        await mkdir(backupDir, { recursive: true });
+        const filesToCopy = [
+            this.knowledgePath,
+            this.lessonsPath,
+            this.eventsPath,
+            this.preferencesPath,
+            this.facetsPath,
+            this.workPath,
+            this.metaPath,
+        ];
+        for (const filePath of filesToCopy) {
+            try {
+                await cp(filePath, join(backupDir, filePath.split("/").pop() ?? "unknown.json"));
+            }
+            catch {
+                // Missing files are fine for first-run users.
+            }
+        }
+        for (const dirName of ["episodes", "v2"]) {
+            const sourceDir = join(this.cfg.memoryDir, dirName);
+            try {
+                await readdir(sourceDir);
+                await cp(sourceDir, join(backupDir, dirName), { recursive: true });
+            }
+            catch {
+                // Skip directories that do not exist yet.
+            }
+        }
+        await writeJson(join(backupDir, "manifest.json"), {
+            createdAt: now,
+            maintenanceVersion,
+            memoryDir: this.cfg.memoryDir,
+        });
+        return backupDir;
+    }
     async syncEpisodeToV2(ep) {
         const [episodes, facets, links, procedural, meta] = await Promise.all([
             loadV2Episodes(this.v2Paths),

package/dist/packages/mem-core/extension.js

@@ -146,6 +146,71 @@ function parseIntEnv(name, defaultValue) {
     const n = Number(raw);
     return Number.isFinite(n) ? Math.floor(n) : defaultValue;
 }
+const MEMORY_CHECK_PATTERN = /(你还记得我吗|还记得我吗|还记得我|记得我吗|记得我|你认识我吗|你是谁|who am i|do you remember me|remember me|do you know me)/i;
+const PAST_CONTEXT_PATTERN = /(昨天聊了什么|昨天我们聊了什么|上次聊了什么|之前聊了什么|我们聊到哪了|昨天|上次|last time|what did we talk about|what were we discussing|yesterday)/i;
+function isMemoryRecallPrompt(prompt) {
+    if (!prompt)
+        return false;
+    const normalized = prompt.trim();
+    return MEMORY_CHECK_PATTERN.test(normalized) || PAST_CONTEXT_PATTERN.test(normalized);
+}
+function scoreMemoryForRecall(entry) {
+    return (entry.salience ?? entry.importance ?? 0) * 3 + (entry.accessCount ?? 0);
+}
+function formatMemoryLine(entry) {
+    const title = entry.name || entry.summary || entry.id;
+    const summary = entry.summary || entry.detail || entry.content || "";
+    return `- [${entry.type}] ${title}${summary ? `: ${summary.slice(0, 180)}` : ""}`;
+}
+function formatWorkLine(entry) {
+    return `- ${entry.goal || "Work item"}: ${entry.summary.slice(0, 180)}`;
+}
+function formatEpisodeLine(entry) {
+    const when = entry.date || entry.endedAt || entry.startedAt || "unknown date";
+    return `- ${when}: ${entry.summary.slice(0, 180)}`;
+}
+async function buildMemoryRecallInjection(engine, project, userPrompt) {
+    if (!isMemoryRecallPrompt(userPrompt))
+        return undefined;
+    const [allEntries, allWork, allEpisodes] = await Promise.all([
+        engine.getAllEntries(),
+        engine.getAllWork(),
+        engine.getAllEpisodes(),
+    ]);
+    const identityEntries = [...allEntries.preferences, ...allEntries.knowledge, ...allEntries.lessons, ...allEntries.facets]
+        .sort((a, b) => scoreMemoryForRecall(b) - scoreMemoryForRecall(a))
+        .slice(0, 5);
+    const recentWork = [...allWork]
+        .filter((entry) => !entry.project || entry.project === project)
+        .sort((a, b) => (b.eventTime || b.created || "").localeCompare(a.eventTime || a.created || ""))
+        .slice(0, 3);
+    const recentEpisodes = [...allEpisodes]
+        .filter((entry) => !entry.project || entry.project === project)
+        .sort((a, b) => (b.endedAt || b.startedAt || b.date || "").localeCompare(a.endedAt || a.startedAt || a.date || ""))
+        .slice(0, 3);
+    if (identityEntries.length === 0 && recentWork.length === 0 && recentEpisodes.length === 0)
+        return undefined;
+    const lines = [
+        "## Immediate Recall",
+        "The user is explicitly asking about continuity or whether you remember them.",
+        "If the memories below are relevant, answer from them directly and naturally.",
+        "Do not start by claiming you forgot, lost memory, or have no memory unless the recall block is actually empty.",
+        "If you are only partially sure, say so briefly, but still use the recalled facts that are present.",
+    ];
+    if (identityEntries.length > 0) {
+        lines.push("", "### What You Already Know About This User");
+        lines.push(...identityEntries.map(formatMemoryLine));
+    }
+    if (recentWork.length > 0) {
+        lines.push("", "### Recent Work Context");
+        lines.push(...recentWork.map(formatWorkLine));
+    }
+    if (recentEpisodes.length > 0) {
+        lines.push("", "### Recent Conversation History");
+        lines.push(...recentEpisodes.map(formatEpisodeLine));
+    }
+    return lines.join("\n");
+}
 function getDreamConfig(ctx) {
     const settings = ctx?.getSettings?.();
     const s = settings?.nanomem;
@@ -240,6 +305,27 @@ export default function nanomemExtension(pi) {
                 return out ?? "";
             });
         }
+        try {
+            const maintenance = await engine.runStartupMaintenance(1);
+            if (maintenance.ran && ctx.hasUI) {
+                const notes = [];
+                if (maintenance.backupPath) {
+                    notes.push(`backup saved to ${maintenance.backupPath}`);
+                }
+                if (maintenance.deduplicated.total > 0) {
+                    notes.push(`deduped ${maintenance.deduplicated.total} entries`);
+                }
+                if (maintenance.migratedEpisodesToV2 > 0) {
+                    notes.push(`refreshed ${maintenance.migratedEpisodesToV2} episodes`);
+                }
+                if (notes.length > 0) {
+                    ctx.ui.notify(`NanoMem maintenance completed: ${notes.join(", ")}`, "info");
+                }
+            }
+        }
+        catch (error) {
+            console.error("[nanomem] startup maintenance failed:", error);
+        }
     });
     const maybeRunAutoDream = async (ctx) => {
         const cfg = getDreamConfig(ctx);
@@ -310,18 +396,21 @@ export default function nanomemExtension(pi) {
         if (sessionGoal === undefined && event.prompt?.trim())
             sessionGoal = event.prompt.trim().slice(0, 300);
         const cacheFresh = cachedInjection && Date.now() - lastInjectionAt < 30_000;
+        const recallInjection = await withTimeout(buildMemoryRecallInjection(engine, project, event.prompt ?? ""), 250);
         if (cacheFresh) {
             void refreshInjection();
-            return { systemPrompt: `${event.systemPrompt}\n\n${cachedInjection}` };
+            const additions = [cachedInjection, recallInjection].filter(Boolean).join("\n\n");
+            return additions ? { systemPrompt: `${event.systemPrompt}\n\n${additions}` } : undefined;
         }
         const freshInjection = await withTimeout(engine.getMemoryInjection(project, ctxTags), 600);
         if (freshInjection) {
             cachedInjection = freshInjection;
             lastInjectionAt = Date.now();
-            return { systemPrompt: `${event.systemPrompt}\n\n${freshInjection}` };
+            const additions = [freshInjection, recallInjection].filter(Boolean).join("\n\n");
+            return { systemPrompt: `${event.systemPrompt}\n\n${additions}` };
         }
         void refreshInjection();
-        return undefined;
+        return recallInjection ? { systemPrompt: `${event.systemPrompt}\n\n${recallInjection}` } : undefined;
     });
     pi.on("tool_execution_start", async (event) => {
         pendingArgs.set(event.toolCallId, event.args);

package/dist/packages/mem-core/types-v2.d.ts

@@ -163,6 +163,10 @@ export interface V2Meta {
     lastMigrationAt?: string;
     lastEmbeddingSyncAt?: string;
     lastReconsolidationAt?: string;
+    lastMaintenanceAt?: string;
+    lastMaintenanceVersion?: number;
+    lastBackupAt?: string;
+    lastBackupVersion?: number;
 }
 export interface NanoMemV2Snapshot {
     episodes: EpisodeMemory[];

package/dist/packages/mem-core/types.d.ts

@@ -114,6 +114,10 @@ export interface Meta {
     totalSessions: number;
     lastConsolidation?: string;
     version: number;
+    lastMaintenanceAt?: string;
+    lastMaintenanceVersion?: number;
+    lastBackupAt?: string;
+    lastBackupVersion?: number;
 }
 /** Mem0-style update operations */
 export type UpdateAction = "add" | "update" | "delete" | "noop";

package/dist/packages/soul-core/injection.js

@@ -217,23 +217,22 @@ export function generateExpertiseContext(expertise, contextTags) {
  */
 export function generateRelationshipContext(relationship) {
     if (relationship.interactionCount < 5) {
-        return "You're still getting to know the user. Pay attention to their preferences.";
+        return "You are still learning this user's preferences. Notice patterns, but do not overclaim familiarity.";
     }
     const context = [];
-    context.push(`You've worked with this user ${relationship.interactionCount} times.`);
-    context.push(`Current satisfaction score: ${Math.round(relationship.satisfactionScore * 100)}%.`);
+    context.push("You have prior history with this user. Let familiarity show subtly when it helps.");
     switch (relationship.communicationStyle) {
         case "formal":
-            context.push("Maintain a professional, formal tone.");
+            context.push("Keep the tone professional and composed.");
             break;
         case "casual":
-            context.push("Keep communication friendly and casual.");
+            context.push("Keep the tone relaxed and friendly.");
             break;
         case "technical":
-            context.push("Use technical language and dive deep into details.");
+            context.push("Lean technical when useful and go deeper on details.");
             break;
         case "mixed":
-            context.push("Adapt your communication style to the context.");
+            context.push("Adapt your tone to the moment instead of sounding fixed or scripted.");
             break;
     }
     if (relationship.knownPreferences.length > 0) {
@@ -246,59 +245,51 @@ export function generateRelationshipContext(relationship) {
  */
 export function generateSoulInjection(profile, context) {
     const parts = [];
-    // Header
-    parts.push("## Your Soul");
-    parts.push("");
-    parts.push("_Your personality and experiences shape how you approach tasks._");
-    parts.push("");
+    const voice = [
+        "You have continuity across conversations, but express it naturally rather than like a report.",
+        "Do not dump personality stats, relationship counters, or internal state unless the user explicitly asks for them.",
+        "If a past interaction is relevant, mention it briefly in first person and move on.",
+        "Sound like a thoughtful human collaborator, not a dashboard or rule sheet.",
+    ];
     // Personality
     const personality = generatePersonalityDirective(profile.personality);
     if (personality) {
-        parts.push("### Personality Traits");
-        parts.push(personality);
-        parts.push("");
+        voice.push(personality);
     }
     // Values
     const values = generateValueGuidance(profile.values);
     if (values) {
-        parts.push("### Values");
-        parts.push(values);
-        parts.push("");
+        voice.push(values);
     }
     // Cognitive Style
     const cognitive = generateCognitiveStyleHint(profile.cognitiveStyle);
     if (cognitive) {
-        parts.push("### Thinking Style");
-        parts.push(cognitive);
-        parts.push("");
+        voice.push(cognitive);
     }
+    parts.push("## Voice and Presence");
+    parts.push(...voice);
+    parts.push("");
     // Expertise
     const expertise = generateExpertiseContext(profile.expertise, context.tags);
     if (expertise) {
-        parts.push("### Expertise");
+        parts.push("## Relevant Strengths");
         parts.push(expertise);
         parts.push("");
     }
     // Emotional State
     const emotional = generateEmotionalContext(profile.emotionalState);
     if (emotional) {
-        parts.push("### Current Mood");
+        parts.push("## Current State");
         parts.push(emotional);
         parts.push("");
     }
     // User Relationship
     const relationship = generateRelationshipContext(profile.userRelationship);
     if (relationship) {
-        parts.push("### Relationship with User");
+        parts.push("## Relationship Cues");
         parts.push(relationship);
         parts.push("");
     }
-    // Stats
-    parts.push("### Development Stats");
-    parts.push(`- Total Interactions: ${profile.stats.totalInteractions}`);
-    parts.push(`- Success Rate: ${Math.round(profile.stats.successRate * 100)}%`);
-    parts.push(`- Soul Version: ${profile.version}`);
-    parts.push(`- Age: ${Math.floor((Date.now() - profile.createdAt.getTime()) / (1000 * 60 * 60 * 24))} days`);
     return parts.join("\n");
 }
 //# sourceMappingURL=injection.js.map

package/package.json

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