@pencil-agent/nano-pencil 1.11.21 → 1.11.23

package/dist/builtin-extensions.js

@@ -16,6 +16,7 @@ const BUNDLED_SIMPLIFY_EXTENSION = join(__dirname, "extensions", "optional", "si
 const BUNDLED_LINK_WORLD_EXTENSION = join(__dirname, "extensions", "defaults", "link-world", "index.js");
 const BUNDLED_SECURITY_AUDIT_EXTENSION = join(__dirname, "extensions", "defaults", "security-audit", "index.js");
 const BUNDLED_SOUL_EXTENSION = join(__dirname, "extensions", "defaults", "soul", "index.js");
+const BUNDLED_PRESENCE_EXTENSION = join(__dirname, "extensions", "defaults", "presence", "index.js");
 const BUNDLED_INTERVIEW_EXTENSION = join(__dirname, "extensions", "defaults", "interview", "index.js");
 const BUNDLED_LOOP_EXTENSION = join(__dirname, "extensions", "defaults", "loop", "index.js");
 const BUNDLED_TEAM_EXTENSION = join(__dirname, "extensions", "defaults", "team", "index.js");
@@ -119,6 +120,14 @@ export function getBuiltinExtensionPaths() {
         if (existsSync(soulTs))
             paths.push(soulTs);
     }
+    if (existsSync(BUNDLED_PRESENCE_EXTENSION)) {
+        paths.push(BUNDLED_PRESENCE_EXTENSION);
+    }
+    else {
+        const presenceTs = join(__dirname, "extensions", "defaults", "presence", "index.ts");
+        if (existsSync(presenceTs))
+            paths.push(presenceTs);
+    }
     // === Interview 扩展（需求澄清）===
     // Placed after Soul to ensure Interview probe sees both Mem + Soul style/systemPrompt injections.
     if (existsSync(BUNDLED_INTERVIEW_EXTENSION)) {

package/dist/core/messages.d.ts

@@ -10,6 +10,7 @@ export declare const COMPACTION_SUMMARY_PREFIX = "The conversation history befor
 export declare const COMPACTION_SUMMARY_SUFFIX = "\n</summary>";
 export declare const BRANCH_SUMMARY_PREFIX = "The following is a summary of a branch that this conversation came back from:\n\n<summary>\n";
 export declare const BRANCH_SUMMARY_SUFFIX = "</summary>";
+export declare const CUSTOM_MESSAGE_TYPES_EXCLUDED_FROM_CONTEXT: Set<string>;
 /**
  * Message type for bash executions via the ! command.
  */

package/dist/core/messages.js

@@ -9,6 +9,7 @@ export const BRANCH_SUMMARY_PREFIX = `The following is a summary of a branch tha
 <summary>
 `;
 export const BRANCH_SUMMARY_SUFFIX = `</summary>`;
+export const CUSTOM_MESSAGE_TYPES_EXCLUDED_FROM_CONTEXT = new Set(["presence"]);
 /**
  * Convert a BashExecutionMessage to user message text for LLM context.
  */
@@ -81,6 +82,9 @@ export function convertToLlm(messages) {
                     timestamp: m.timestamp,
                 };
             case "custom": {
+                if (CUSTOM_MESSAGE_TYPES_EXCLUDED_FROM_CONTEXT.has(m.customType)) {
+                    return undefined;
+                }
                 const content = typeof m.content === "string" ? [{ type: "text", text: m.content }] : m.content;
                 return {
                     role: "user",

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

@@ -22,8 +22,12 @@ Usage:
   nanomem search-v2 <query>  Semantic search across V2 episode/facet/procedure memory
   nanomem forget <id>        Remove a memory entry by ID
   nanomem dedup              Deduplicate all memories (merge similar entries, keep best)
+  nanomem archive            Archive stale low-value memories into _archive/
+  nanomem restore <id>       Restore one archived memory item by ID
   nanomem export             Export all memories as JSON to stdout
   nanomem export-v2          Export NanoMem v2 episodic bridge data as JSON to stdout
+  nanomem export-archive     Export archived memories as JSON to stdout
+  nanomem inspect-v2         Inspect V2 memory chains and conflict signals
   nanomem sync-v2-embeddings Sync the V2 embedding index
   nanomem insights [--output <path>]   Generate full HTML insights report (default: ./nanomem-insights.html)
   nanomem insights --simple [--output <path>]   Generate simple insights report (rules-only, no LLM)
@@ -38,11 +42,19 @@ Usage:
         console.log(`Lessons: ${s.lessons}`);
         console.log(`Preferences: ${s.preferences}`);
         console.log(`Work: ${s.work}`);
+        console.log(`Archived Knowledge: ${s.archivedKnowledge}`);
+        console.log(`Archived Lessons: ${s.archivedLessons}`);
+        console.log(`Archived Events: ${s.archivedEvents}`);
+        console.log(`Archived Preferences: ${s.archivedPreferences}`);
+        console.log(`Archived Facets: ${s.archivedFacets}`);
+        console.log(`Archived Work: ${s.archivedWork}`);
         console.log(`Episodes: ${s.episodes}`);
         console.log(`V2 Episodes: ${v2.episodes}`);
         console.log(`V2 Episode Facets: ${v2.facets}`);
         console.log(`V2 Semantic: ${v2.semantic}`);
         console.log(`V2 Procedures: ${v2.procedural}`);
+        console.log(`Archived V2 Semantic: ${v2.archivedSemantic}`);
+        console.log(`Archived V2 Procedures: ${v2.archivedProcedural}`);
         console.log(`V2 Links: ${v2.links}`);
         console.log(`V2 Embeddings: ${v2.embeddings}`);
         if (v2.lastEmbeddingSyncAt)
@@ -109,16 +121,88 @@ Usage:
         }
         return;
     }
+    if (sub === "archive") {
+        const result = await engine.archiveStaleMemories();
+        if (result.total === 0) {
+            console.log("No stale memories were archived.");
+            return;
+        }
+        console.log(`Archived ${result.total} stale memory item(s):`);
+        if (result.knowledge)
+            console.log(`  knowledge: ${result.knowledge}`);
+        if (result.lessons)
+            console.log(`  lessons: ${result.lessons}`);
+        if (result.events)
+            console.log(`  events: ${result.events}`);
+        if (result.preferences)
+            console.log(`  preferences: ${result.preferences}`);
+        if (result.facets)
+            console.log(`  facets: ${result.facets}`);
+        if (result.work)
+            console.log(`  work: ${result.work}`);
+        if (result.semantic)
+            console.log(`  semantic: ${result.semantic}`);
+        if (result.procedural)
+            console.log(`  procedural: ${result.procedural}`);
+        return;
+    }
+    if (sub === "restore") {
+        const id = args[1];
+        if (!id) {
+            console.error("Usage: nanomem restore <id>");
+            process.exit(1);
+        }
+        const result = await engine.restoreArchivedEntry(id);
+        console.log(result.ok ? `Restored archived ${result.location} entry ${id}` : `Archived entry ${id} not found`);
+        return;
+    }
     if (sub === "export") {
         const data = await engine.exportAll();
         console.log(JSON.stringify(data, null, 2));
         return;
     }
+    if (sub === "export-archive") {
+        const data = await engine.exportArchive();
+        console.log(JSON.stringify(data, null, 2));
+        return;
+    }
     if (sub === "export-v2") {
         const data = await engine.exportAllV2();
         console.log(JSON.stringify(data, null, 2));
         return;
     }
+    if (sub === "inspect-v2") {
+        const data = await engine.inspectV2Memory();
+        console.log(`Episodes: ${data.counts.episodes}`);
+        console.log(`Facets: ${data.counts.facets}`);
+        console.log(`Semantic: ${data.counts.semantic}`);
+        console.log(`Procedural: ${data.counts.procedural}`);
+        console.log(`Active Procedural: ${data.counts.activeProcedural}`);
+        console.log(`Superseded Procedural: ${data.counts.supersededProcedural}`);
+        console.log(`Procedure Chains: ${data.counts.procedureChains}`);
+        console.log(`Procedural Conflicts: ${data.counts.proceduralConflicts}`);
+        console.log(`Semantic Conflicts: ${data.counts.semanticConflicts}`);
+        if (data.procedureChains.length) {
+            console.log("\nProcedure Version Chains:");
+            for (const chain of data.procedureChains) {
+                console.log(`- ${chain.name} [${chain.status}] depth=${chain.versionDepth} root=${chain.rootId}`);
+                console.log(`  ${chain.ids.join(" -> ")}`);
+            }
+        }
+        if (data.proceduralConflicts.length) {
+            console.log("\nProcedural Conflict Signals:");
+            for (const conflict of data.proceduralConflicts.slice(0, 20)) {
+                console.log(`- ${conflict.aName} (${conflict.aId}) <-> ${conflict.bName} (${conflict.bId}) score=${conflict.score} — ${conflict.reason}`);
+            }
+        }
+        if (data.semanticConflicts.length) {
+            console.log("\nSemantic Conflict Signals:");
+            for (const conflict of data.semanticConflicts.slice(0, 20)) {
+                console.log(`- ${conflict.aName} (${conflict.aId}) <-> ${conflict.bName} (${conflict.bId}) — ${conflict.reason}`);
+            }
+        }
+        return;
+    }
     if (sub === "sync-v2-embeddings") {
         const count = await engine.syncV2Embeddings();
         if (count === 0) {

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

@@ -70,6 +70,7 @@ export interface NanomemConfig {
     forgetting: {
         ambientTtlDays: number;
         workTtlDays: number;
+        reviveCooldownDays: number;
     };
     /** Embedding configuration for semantic episodic/procedural recall */
     embeddings: EmbeddingConfig;

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

@@ -41,6 +41,7 @@ const DEFAULT_PROGRESSIVE_RECALL = {
 const DEFAULT_FORGETTING = {
     ambientTtlDays: 45,
     workTtlDays: 21,
+    reviveCooldownDays: 7,
 };
 const DEFAULT_EMBEDDINGS = {
     enabled: true,

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

@@ -6,11 +6,13 @@
  */
 import { type NanomemConfig } from "./config.js";
 import type { DeveloperPersona, Episode, ExtractedItem, FullInsightsReport, HumanInsight, InsightsReport, AlignmentSnapshot, LlmFn, MemoryEntry, MemoryScope, Meta, RootCauseInsight, WorkEntry } from "./types.js";
-import type { EmbeddingFn, EpisodeFacet, EpisodeMemory, MemoryLink, ProceduralMemory } from "./types-v2.js";
+import type { EmbeddingFn, EpisodeFacet, EpisodeMemory, MemoryLink, ProceduralMemory, SemanticMemory } from "./types-v2.js";
 export declare class NanoMemEngine {
     readonly cfg: NanomemConfig;
     private llmFn?;
     private embeddingFn?;
+    private static readonly AUTO_V2_LINK_PREFIX;
+    private static readonly AUTO_REVIVE_MAX_ITEMS;
     private knowledgePath;
     private lessonsPath;
     private eventsPath;
@@ -20,6 +22,13 @@ export declare class NanoMemEngine {
     private metaPath;
     private episodesDir;
     private v2Paths;
+    private archiveKnowledgePath;
+    private archiveLessonsPath;
+    private archiveEventsPath;
+    private archivePreferencesPath;
+    private archiveFacetsPath;
+    private archiveWorkPath;
+    private archiveV2Paths;
     constructor(overrides?: Partial<NanomemConfig>, llmFn?: LlmFn);
     setLlmFn(fn: LlmFn): void;
     setEmbeddingFn(fn: EmbeddingFn): void;
@@ -76,6 +85,12 @@ export declare class NanoMemEngine {
         facets: number;
         episodes: number;
         work: number;
+        archivedKnowledge: number;
+        archivedLessons: number;
+        archivedEvents: number;
+        archivedPreferences: number;
+        archivedFacets: number;
+        archivedWork: number;
         totalSessions: number;
     }>;
     getV2Stats(): Promise<{
@@ -83,6 +98,8 @@ export declare class NanoMemEngine {
         facets: number;
         semantic: number;
         procedural: number;
+        archivedSemantic: number;
+        archivedProcedural: number;
         links: number;
         embeddings: number;
         lastEmbeddingSyncAt?: string;
@@ -95,6 +112,12 @@ export declare class NanoMemEngine {
         preferences: MemoryEntry[];
         facets: MemoryEntry[];
     }>;
+    getRuntimeIdentityEntries(): Promise<{
+        knowledge: MemoryEntry[];
+        lessons: MemoryEntry[];
+        preferences: MemoryEntry[];
+        facets: MemoryEntry[];
+    }>;
     getAllWork(): Promise<WorkEntry[]>;
     getAllEpisodes(): Promise<Episode[]>;
     runStartupMaintenance(maintenanceVersion?: number): Promise<{
@@ -110,6 +133,17 @@ export declare class NanoMemEngine {
             total: number;
         };
         migratedEpisodesToV2: number;
+        archived: {
+            knowledge: number;
+            lessons: number;
+            events: number;
+            preferences: number;
+            facets: number;
+            work: number;
+            semantic: number;
+            procedural: number;
+            total: number;
+        };
     }>;
     private createMaintenanceBackup;
     private syncEpisodeToV2;
@@ -126,6 +160,14 @@ export declare class NanoMemEngine {
         total: number;
     }>;
     searchEntries(query: string, scope?: MemoryScope): Promise<MemoryEntry[]>;
+    autoReviveRelevantArchive(query: string, scope?: MemoryScope, options?: {
+        maxItems?: number;
+        legacyThreshold?: number;
+        v2Threshold?: number;
+    }): Promise<Array<{
+        id: string;
+        location: "knowledge" | "lessons" | "events" | "preferences" | "facets" | "semantic" | "procedural" | "work";
+    }>>;
     getAlignmentSnapshot(): Promise<AlignmentSnapshot>;
     forgetEntry(id: string): Promise<boolean>;
     exportAll(): Promise<{
@@ -138,6 +180,16 @@ export declare class NanoMemEngine {
         episodes: Episode[];
         meta: Meta;
     }>;
+    exportArchive(): Promise<{
+        knowledge: MemoryEntry[];
+        lessons: MemoryEntry[];
+        events: MemoryEntry[];
+        preferences: MemoryEntry[];
+        facets: MemoryEntry[];
+        work: WorkEntry[];
+        semantic: SemanticMemory[];
+        procedural: ProceduralMemory[];
+    }>;
     exportAllV2(): Promise<{
         episodes: EpisodeMemory[];
         facets: EpisodeFacet[];
@@ -145,6 +197,60 @@ export declare class NanoMemEngine {
         procedural: ProceduralMemory[];
         links: MemoryLink[];
     }>;
+    rebuildV2Links(): Promise<{
+        total: number;
+        auto: number;
+    }>;
+    archiveStaleMemories(now?: string): Promise<{
+        knowledge: number;
+        lessons: number;
+        events: number;
+        preferences: number;
+        facets: number;
+        work: number;
+        semantic: number;
+        procedural: number;
+        total: number;
+    }>;
+    restoreArchivedEntry(id: string): Promise<{
+        ok: boolean;
+        location?: "knowledge" | "lessons" | "events" | "preferences" | "facets" | "work" | "semantic" | "procedural";
+    }>;
+    inspectV2Memory(project?: string, scope?: MemoryScope): Promise<{
+        counts: {
+            episodes: number;
+            facets: number;
+            semantic: number;
+            procedural: number;
+            activeProcedural: number;
+            supersededProcedural: number;
+            semanticConflicts: number;
+            proceduralConflicts: number;
+            procedureChains: number;
+        };
+        procedureChains: Array<{
+            rootId: string;
+            name: string;
+            status: ProceduralMemory["status"];
+            versionDepth: number;
+            ids: string[];
+        }>;
+        proceduralConflicts: Array<{
+            aId: string;
+            bId: string;
+            aName: string;
+            bName: string;
+            score: number;
+            reason: string;
+        }>;
+        semanticConflicts: Array<{
+            aId: string;
+            bId: string;
+            aName: string;
+            bName: string;
+            reason: string;
+        }>;
+    }>;
     generateFullInsights(): Promise<FullInsightsReport>;
     /**
      * 生成增强版洞察报告（包含大白话洞察 + 开发者画像 + 根因分析）
@@ -167,6 +273,30 @@ export declare class NanoMemEngine {
     private filterAndCleanV2Episodes;
     private filterAndCleanV2Facets;
     private filterAndCleanV2Semantic;
+    private mergeArchivedEntries;
+    private mergeArchivedWork;
+    private mergeArchivedV2;
+    private partitionArchivedEntries;
+    private partitionArchivedWork;
+    private partitionArchivedSemantic;
+    private partitionArchivedProcedural;
+    private getLegacyArchiveReason;
+    private inferSemanticRetention;
+    private inferSemanticStability;
+    private inferSemanticImportance;
+    private mapExtractedItemToSemanticType;
+    private upsertSemanticFromExtractedItem;
+    private semanticKindToLegacyType;
+    private semanticToRuntimeEntry;
+    private proceduralToRuntimeEntry;
+    private buildRuntimeMemoryView;
+    private getWorkArchiveReason;
+    private getSemanticArchiveReason;
+    private getProceduralArchiveReason;
+    private buildProceduralChains;
+    private materializeV2Links;
+    private detectProceduralConflicts;
+    private detectSemanticConflicts;
     private buildEmbeddingSourceItems;
     private querySemanticCandidates;
     private scoreEpisodeMemory;