@plur-ai/core 0.4.2 → 0.5.0

package/dist/index.d.ts

@@ -265,10 +265,10 @@ declare const EngramSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     type: "behavioral" | "architectural" | "procedural" | "terminological";
     status: "active" | "dormant" | "retired" | "candidate";
+    scope: string;
     id: string;
     version: number;
     consolidated: boolean;
-    scope: string;
     visibility: "private" | "public" | "template";
     statement: string;
     derivation_count: number;
@@ -359,8 +359,8 @@ declare const EngramSchema: z.ZodObject<{
 }, {
     type: "behavioral" | "architectural" | "procedural" | "terminological";
     status: "active" | "dormant" | "retired" | "candidate";
-    id: string;
     scope: string;
+    id: string;
     statement: string;
     version?: number | undefined;
     consolidated?: boolean | undefined;
@@ -595,6 +595,23 @@ declare const EpisodeSchema: z.ZodObject<{
 }>;
 type Episode = z.infer<typeof EpisodeSchema>;
 
+declare const StoreEntrySchema: z.ZodObject<{
+    path: z.ZodString;
+    scope: z.ZodString;
+    shared: z.ZodDefault<z.ZodBoolean>;
+    readonly: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    scope: string;
+    shared: boolean;
+    readonly: boolean;
+}, {
+    path: string;
+    scope: string;
+    shared?: boolean | undefined;
+    readonly?: boolean | undefined;
+}>;
+type StoreEntry = z.infer<typeof StoreEntrySchema>;
 declare const PlurConfigSchema: z.ZodObject<{
     auto_learn: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
     auto_capture: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
@@ -617,6 +634,22 @@ declare const PlurConfigSchema: z.ZodObject<{
     }>>>;
     allow_secrets: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
     index: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    stores: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        scope: z.ZodString;
+        shared: z.ZodDefault<z.ZodBoolean>;
+        readonly: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        scope: string;
+        shared: boolean;
+        readonly: boolean;
+    }, {
+        path: string;
+        scope: string;
+        shared?: boolean | undefined;
+        readonly?: boolean | undefined;
+    }>, "many">>>;
 }, "strip", z.ZodTypeAny, {
     auto_learn?: boolean | undefined;
     auto_capture?: boolean | undefined;
@@ -631,6 +664,12 @@ declare const PlurConfigSchema: z.ZodObject<{
     } | undefined;
     allow_secrets?: boolean | undefined;
     index?: boolean | undefined;
+    stores?: {
+        path: string;
+        scope: string;
+        shared: boolean;
+        readonly: boolean;
+    }[] | undefined;
 }, {
     auto_learn?: boolean | undefined;
     auto_capture?: boolean | undefined;
@@ -645,6 +684,12 @@ declare const PlurConfigSchema: z.ZodObject<{
     } | undefined;
     allow_secrets?: boolean | undefined;
     index?: boolean | undefined;
+    stores?: {
+        path: string;
+        scope: string;
+        shared?: boolean | undefined;
+        readonly?: boolean | undefined;
+    }[] | undefined;
 }>;
 type PlurConfig = z.infer<typeof PlurConfigSchema>;
 
@@ -653,6 +698,20 @@ interface LearnContext {
     scope?: string;
     domain?: string;
     source?: string;
+    tags?: string[];
+    rationale?: string;
+    visibility?: 'private' | 'public' | 'template';
+    knowledge_anchors?: Array<{
+        path: string;
+        relevance?: string;
+        snippet?: string;
+    }>;
+    dual_coding?: {
+        example?: string;
+        analogy?: string;
+    };
+    abstract?: string | null;
+    derived_from?: string | null;
 }
 /**
  * Function that calls an LLM. Model-agnostic — consumer provides this.
@@ -680,6 +739,7 @@ interface InjectionResult {
     consider: string;
     count: number;
     tokens_used: number;
+    injected_ids: string[];
 }
 interface CaptureContext {
     agent?: string;
@@ -1268,6 +1328,8 @@ declare class Plur {
     recallExpanded(query: string, options: RecallOptions & {
         llm: LlmFunction;
     }): Promise<Engram[]>;
+    /** Get a single engram by ID, regardless of status. Returns null if not found. */
+    getById(id: string): Engram | null;
     /** List all active engrams, optionally filtered by scope/domain. No search — returns all matches. */
     list(options?: {
         scope?: string;
@@ -1283,7 +1345,7 @@ declare class Plur {
     /** Scored injection with embedding boost when available. Falls back to BM25 if embeddings not installed. */
     injectHybrid(task: string, options?: InjectOptions): Promise<InjectionResult>;
     private _formatInjection;
-    /** Update feedback_signals and adjust retrieval_strength. */
+    /** Update feedback_signals and adjust retrieval_strength. Searches packs if not found in personal engrams. */
     feedback(id: string, signal: 'positive' | 'negative' | 'neutral'): void;
     /** Save extracted meta-engrams to the engram store. Skips IDs that already exist. */
     saveMetaEngrams(metas: Engram[]): {
@@ -1303,6 +1365,8 @@ declare class Plur {
     reindex(): void;
     /** Sync SQLite index after YAML write (no-op if index disabled) */
     private _syncIndex;
+    /** Search packs for an engram by ID and apply feedback, writing back to the pack's engrams.yaml. */
+    private _feedbackPack;
     /** Capture an episodic memory. */
     capture(summary: string, context?: CaptureContext): Episode;
     /** Query the episode timeline. */
@@ -1332,6 +1396,19 @@ declare class Plur {
     syncStatus(): SyncStatus;
     /** Return system health info. */
     status(): StatusResult;
+    /** Register an additional engram store. */
+    addStore(storePath: string, scope: string, options?: {
+        shared?: boolean;
+        readonly?: boolean;
+    }): void;
+    /** List all configured stores. */
+    listStores(): Array<{
+        path: string;
+        scope: string;
+        shared: boolean;
+        readonly: boolean;
+        engram_count: number;
+    }>;
 }
 
-export { type AlignmentResult, type Association, type CaptureContext, type DomainCoverage, DomainCoverageSchema, type Engram, type EngramCluster, type Episode, type EvidenceEntry, EvidenceEntrySchema, type ExtractOptions, type ExtractionResult, type Falsification, FalsificationSchema, type HierarchyPosition, HierarchyPositionSchema, IndexedStorage, type IngestCandidate, type IngestOptions, type InjectOptions, type InjectionResult, type KnowledgeAnchor, type LearnContext, type LlmFunction, type MemberAlignment, type MetaConfidence, MetaConfidenceSchema, type MetaField, MetaFieldSchema, PLATITUDE_PATTERNS, type PackManifest, Plur, type PlurConfig, type PlurPaths, type RecallOptions, type RelationalAnalysis, type RelationalTriple, SessionBreadcrumbs, type StatusResult, type StructuralTemplate, StructuralTemplateSchema, type SyncResult, type SyncStatus, type TimelineQuery, type TypedRole, type ValidationResult, type VersionCheckResult, alignCluster, analyzeStructure, checkForUpdate, classifyPolarity, clearVersionCache, clusterByStructure, computeConfidence, computeMetaConfidence, confidenceBand, detectPlurStorage, detectSecrets, engramSearchText, extractMetaEngrams, formulateMetaEngram, generateGuardrails, getCachedUpdateCheck, isPlatitude, organizeHierarchy, tokenSimilarity, validateMetaEngram };
+export { type AlignmentResult, type Association, type CaptureContext, type DomainCoverage, DomainCoverageSchema, type Engram, type EngramCluster, type Episode, type EvidenceEntry, EvidenceEntrySchema, type ExtractOptions, type ExtractionResult, type Falsification, FalsificationSchema, type HierarchyPosition, HierarchyPositionSchema, IndexedStorage, type IngestCandidate, type IngestOptions, type InjectOptions, type InjectionResult, type KnowledgeAnchor, type LearnContext, type LlmFunction, type MemberAlignment, type MetaConfidence, MetaConfidenceSchema, type MetaField, MetaFieldSchema, PLATITUDE_PATTERNS, type PackManifest, Plur, type PlurConfig, type PlurPaths, type RecallOptions, type RelationalAnalysis, type RelationalTriple, SessionBreadcrumbs, type StatusResult, type StoreEntry, type StructuralTemplate, StructuralTemplateSchema, type SyncResult, type SyncStatus, type TimelineQuery, type TypedRole, type ValidationResult, type VersionCheckResult, alignCluster, analyzeStructure, checkForUpdate, classifyPolarity, clearVersionCache, clusterByStructure, computeConfidence, computeMetaConfidence, confidenceBand, detectPlurStorage, detectSecrets, engramSearchText, extractMetaEngrams, formulateMetaEngram, generateGuardrails, getCachedUpdateCheck, isPlatitude, organizeHierarchy, tokenSimilarity, validateMetaEngram };

package/dist/index.js

@@ -11,6 +11,10 @@ import {
 } from "./chunk-KMVQYBNP.js";
 import "./chunk-2ZDO52B4.js";
 
+// src/index.ts
+import * as fs3 from "fs";
+import yaml5 from "js-yaml";
+
 // src/storage.ts
 import { existsSync, mkdirSync } from "fs";
 import { join } from "path";
@@ -433,6 +437,12 @@ import yaml2 from "js-yaml";
 
 // src/schemas/config.ts
 import { z as z3 } from "zod";
+var StoreEntrySchema = z3.object({
+  path: z3.string(),
+  scope: z3.string(),
+  shared: z3.boolean().default(false),
+  readonly: z3.boolean().default(false)
+});
 var PlurConfigSchema = z3.object({
   auto_learn: z3.boolean().default(true),
   auto_capture: z3.boolean().default(true),
@@ -446,7 +456,8 @@ var PlurConfigSchema = z3.object({
     co_access: z3.boolean().default(true)
   }).default({}),
   allow_secrets: z3.boolean().default(false),
-  index: z3.boolean().default(false)
+  index: z3.boolean().default(false),
+  stores: z3.array(StoreEntrySchema).default([])
 }).partial();
 
 // src/config.ts
@@ -1996,8 +2007,9 @@ var Plur = class {
         consolidated: false,
         type: context?.type ?? "behavioral",
         scope,
-        visibility: "private",
+        visibility: context?.visibility ?? "private",
         statement,
+        rationale: context?.rationale,
         source: context?.source,
         domain: context?.domain,
         activation: {
@@ -2007,13 +2019,18 @@ var Plur = class {
           last_accessed: now.slice(0, 10)
         },
         feedback_signals: { positive: 0, negative: 0, neutral: 0 },
-        knowledge_anchors: [],
+        knowledge_anchors: (context?.knowledge_anchors ?? []).map((a) => ({
+          path: a.path,
+          relevance: a.relevance ?? "supporting",
+          snippet: a.snippet
+        })),
         associations: [],
         derivation_count: 1,
-        tags: [],
+        tags: context?.tags ?? [],
         pack: null,
-        abstract: null,
-        derived_from: null,
+        abstract: context?.abstract ?? null,
+        derived_from: context?.derived_from ?? null,
+        dual_coding: context?.dual_coding,
         polarity: null,
         relations: conflictIds.length > 0 ? {
           broader: [],
@@ -2074,6 +2091,11 @@ var Plur = class {
     this._reactivateResults(results);
     return results;
   }
+  /** Get a single engram by ID, regardless of status. Returns null if not found. */
+  getById(id) {
+    const engrams = loadEngrams(this.paths.engrams);
+    return engrams.find((e) => e.id === id) ?? null;
+  }
   /** List all active engrams, optionally filtered by scope/domain. No search — returns all matches. */
   list(options) {
     return this._filterEngrams(options);
@@ -2211,20 +2233,26 @@ var Plur = class {
     const considerStr = formatEngrams(result.consider);
     const count = result.directives.length + result.constraints.length + result.consider.length;
     const tokensUsed = result.tokens_used.directives + result.tokens_used.consider;
+    const injected_ids = [
+      ...result.directives.map((e) => e.id),
+      ...result.constraints.map((e) => e.id),
+      ...result.consider.map((e) => e.id)
+    ];
     return {
       directives: directivesStr,
       constraints: constraintsStr,
       consider: considerStr,
       count,
-      tokens_used: tokensUsed
+      tokens_used: tokensUsed,
+      injected_ids
     };
   }
-  /** Update feedback_signals and adjust retrieval_strength. */
+  /** Update feedback_signals and adjust retrieval_strength. Searches packs if not found in personal engrams. */
   feedback(id, signal) {
-    withLock(this.paths.engrams, () => {
+    const found = withLock(this.paths.engrams, () => {
       const engrams = loadEngrams(this.paths.engrams);
       const engram = engrams.find((e) => e.id === id);
-      if (!engram) throw new Error(`Engram not found: ${id}`);
+      if (!engram) return false;
       if (!engram.feedback_signals) {
         engram.feedback_signals = { positive: 0, negative: 0, neutral: 0 };
       }
@@ -2236,7 +2264,10 @@ var Plur = class {
       }
       saveEngrams(this.paths.engrams, engrams);
       this._syncIndex();
+      return true;
     });
+    if (found) return;
+    this._feedbackPack(id, signal);
   }
   /** Save extracted meta-engrams to the engram store. Skips IDs that already exist. */
   saveMetaEngrams(metas) {
@@ -2312,6 +2343,31 @@ var Plur = class {
       this.indexedStorage.syncFromYaml();
     }
   }
+  /** Search packs for an engram by ID and apply feedback, writing back to the pack's engrams.yaml. */
+  _feedbackPack(id, signal) {
+    if (!fs3.existsSync(this.paths.packs)) throw new Error(`Engram not found: ${id}`);
+    for (const entry of fs3.readdirSync(this.paths.packs)) {
+      const packDir = `${this.paths.packs}/${entry}`;
+      if (!fs3.statSync(packDir).isDirectory()) continue;
+      const engramsPath = `${packDir}/engrams.yaml`;
+      if (!fs3.existsSync(engramsPath)) continue;
+      const engrams = loadEngrams(engramsPath);
+      const engram = engrams.find((e) => e.id === id);
+      if (!engram) continue;
+      if (!engram.feedback_signals) {
+        engram.feedback_signals = { positive: 0, negative: 0, neutral: 0 };
+      }
+      engram.feedback_signals[signal] += 1;
+      if (signal === "positive") {
+        engram.activation.retrieval_strength = Math.min(1, engram.activation.retrieval_strength + 0.05);
+      } else if (signal === "negative") {
+        engram.activation.retrieval_strength = Math.max(0, engram.activation.retrieval_strength - 0.1);
+      }
+      saveEngrams(engramsPath, engrams);
+      return;
+    }
+    throw new Error(`Engram not found: ${id}`);
+  }
   /** Capture an episodic memory. */
   capture(summary, context) {
     return captureEpisode(this.paths.episodes, summary, context);
@@ -2385,6 +2441,47 @@ var Plur = class {
       config: this.config
     };
   }
+  /** Register an additional engram store. */
+  addStore(storePath, scope, options) {
+    const config = loadConfig(this.paths.config);
+    const existing = config.stores?.find((s) => s.path === storePath);
+    if (existing) return;
+    const stores = [...config.stores ?? [], {
+      path: storePath,
+      scope,
+      shared: options?.shared ?? false,
+      readonly: options?.readonly ?? false
+    }];
+    let configData = {};
+    try {
+      const raw = fs3.readFileSync(this.paths.config, "utf8");
+      if (raw) configData = yaml5.load(raw) ?? {};
+    } catch {
+    }
+    configData.stores = stores;
+    fs3.writeFileSync(this.paths.config, yaml5.dump(configData, { lineWidth: 120, noRefs: true }));
+    this.config = loadConfig(this.paths.config);
+  }
+  /** List all configured stores. */
+  listStores() {
+    const stores = this.config.stores ?? [];
+    const primary = {
+      path: this.paths.engrams,
+      scope: "global",
+      shared: false,
+      readonly: false,
+      engram_count: loadEngrams(this.paths.engrams).filter((e) => e.status !== "retired").length
+    };
+    const additional = stores.map((s) => {
+      let count = 0;
+      try {
+        count = loadEngrams(s.path).filter((e) => e.status !== "retired").length;
+      } catch {
+      }
+      return { ...s, engram_count: count };
+    });
+    return [primary, ...additional];
+  }
 };
 export {
   DomainCoverageSchema,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plur-ai/core",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",