@pyxmate/memory 1.2.0 → 1.4.0

package/dist/agent-contract.d.ts

@@ -1,4 +1,4 @@
-declare const PYX_MEMORY_INSTRUCTIONS = "Use pyx-memory to search durable project/user memory before assuming prior decisions, and to store concise facts after corrections, bug fixes, design decisions, integration discoveries, gotchas, explicit preferences, or \"remember this\" requests. Store decisions, not deliberation. Include topic and project. Pass eventTime (ISO-8601, when the fact happened or took effect) for any fact that can change or go stale \u2014 job/status changes, decisions that supersede earlier ones, dated events; recency ordering, dated (\"as of\") queries, and stale-vs-current conflict resolution all key off it. Search effort is retrieval depth: quick=strongest, deep=everything including archived/superseded. Use reinforce after memories were actually used, so they surface in quick/medium effort tiers. Use lineage for the history of how a fact changed; pass subject+relation for graph lineage or entryId for a superseded chain. Use record_correction when the user corrects a mistake you made (what was wrong, what to do instead, when it applies); call fetch_applicable_corrections before a task to retrieve the corrections that match it, then decide which to follow \u2014 pyx never auto-applies them. Isolation: userId/teamId are attribution and legacy filters, not authorization or read gates. Use agentId only for trusted per-agent pool isolation (hard filter when set; omit to share a pool); on hosted MaaS/remote MCP it is a within-tenant filter, not a cross-identity security boundary. For per-user/team privacy inside a shared tenant, use namespaces + ReBAC grants via /api/admin/* + ADMIN_API_KEY + TENANT_MODE=multi. callerAccessLevel is sensitivity redaction, not isolation. Trusted stdio/self-host/companion callers may pass scope per call; hosted MaaS/remote MCP derive identity from project/token and strip caller-supplied identity until verified-JWT multi-tenant remote MCP exists. When a question names a time \u2014 explicit or relative (\"last year\", \"\uB450 \uB2EC \uC804\") \u2014 resolve it to an absolute ISO-8601 timestamp yourself and pass it as search anchorTime: results then rank by proximity to this time instead of now, without excluding anything. For count/list questions about a category, pass `enumerationConcept` = the language-agnostic/global category phrase (e.g. \"fitness classes\" / \"\uC6B4\uB3D9 \uC218\uC5C5\"); the caller-supplied hint is resolved by the embedding model, which covers a broad range of languages. pyx also auto-detects English/Korean count phrasing as a best-effort fallback when the hint is omitted. When content names people, organizations, tools, places, events, or key concepts, pass entities and relationships when you can (caller-wins). You build the graph \u2014 the server does not extract it for you unless a self-host operator has configured a BYO extraction endpoint (then caller-passed graph still wins). On a multi-entity store, include at least one relationship connecting the entities, or the store is refused so isolated nodes never accumulate (set entitiesOnly for a deliberate lone entity); triples make edges impossible to omit. Edges matter as much as nodes: without relationships the graph cannot connect related memories. For countable categories the user may later enumerate (\"how many fitness classes / streaming services / pets do I have?\"), add a canonical category CONCEPT node and an IS_A edge from each member to it. A language/synonym variant gives zero-cost exact-match resolution only when it is also a memberful CONCEPT node with member IS_A edges; there is no query-time alias\u2192canonical resolver. pyx resolves count/list category hints at query time via strict embedding over memberful CONCEPT nodes. Use file ingest for documents/images worth persisting; images require a description.";
+declare const PYX_MEMORY_INSTRUCTIONS = "Use pyx-memory for durable memory across sessions, proactively \u2014 do not wait to be told. SEARCH before assuming: at the start of a task, and before proposing an approach or re-deriving a past decision, search memory for the project and topic; resolve relative times (\"last year\", \"\uB450 \uB2EC \uC804\") to an absolute ISO-8601 anchorTime so results rank by proximity to that time. STORE once a fact is settled: corrections, bug fixes (root cause + fix), design/architecture decisions (with reasoning), integration/API/auth/endpoint details, gotchas, explicit preferences, and \"remember this\" requests \u2014 concise facts not deliberation, each with topic and project. Pass eventTime (ISO-8601, when the fact took effect) for anything that can change or go stale; recency ordering, \"as of\" queries, and stale-vs-current resolution all key off it. After a memory informs your work, call reinforce so it stays in the quick/medium tiers (idle never revives it). When the user corrects you, call record_correction; before a task, call fetch_applicable_corrections (pyx never auto-applies them). When content names people, organizations, tools, places, events, or key concepts, pass entities and relationships \u2014 you build the graph, the server does not extract it; a multi-entity store with no connecting edge is refused. Match search effort to need: quick (default, strongest) for routine recall, deep for full/archived history; use lineage to trace how a fact changed. userId/teamId/agentId and callerAccessLevel are attribution filters and sensitivity redaction, not a security isolation boundary \u2014 for tenant/namespace/ReBAC detail see the installed Persistent Memory rule.";
 declare const PERSISTENT_MEMORY_SECTION: string;
 declare function buildDesignGuide({ appName }: {
     appName: string;

package/dist/agent-contract.mjs

@@ -13,7 +13,7 @@ import {
   buildAgentSnippet,
   buildDesignGuide,
   buildGraphStructuringPrompt
-} from "./chunk-XHEVB23R.mjs";
+} from "./chunk-ML6VKYAL.mjs";
 export {
   AGENT_TARGETS,
   PERSISTENT_MEMORY_SECTION,

package/dist/{chunk-3SDKJ5TB.mjs → chunk-BS6K64SA.mjs}

@@ -1,7 +1,129 @@
-import {
-  RAGStrategy,
-  mergeExtractedEntities
-} from "./chunk-X6AYWXW7.mjs";
+// ../shared/src/constants/defaults.ts
+var DEFAULTS = {
+  DATA_DIR: "./data",
+  VECTOR_PROVIDER: "lancedb",
+  MEMORY_SERVER_PORT: 7822
+};
+
+// ../shared/src/graph/extraction.ts
+function normalizeGraphLabel(value, fallback) {
+  const normalized = value.trim().toUpperCase().replace(/[^A-Z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+  return normalized.length > 0 ? normalized : fallback;
+}
+function normalizeNameKey(name) {
+  return name.trim().toLowerCase().replace(/\s+/g, " ");
+}
+function relationshipKey(relationship) {
+  return [
+    relationship.source.trim().toLowerCase(),
+    relationship.target.trim().toLowerCase(),
+    normalizeGraphLabel(relationship.type, "RELATED_TO")
+  ].join("\0");
+}
+function mergeExtractedEntities(callerEntities, callerRelationships, extracted) {
+  const entities = [...callerEntities ?? []];
+  const relationships = [...callerRelationships ?? []];
+  const nameByLowercase = /* @__PURE__ */ new Map();
+  for (const entity of entities) {
+    const key = entity.name.toLowerCase();
+    if (!nameByLowercase.has(key)) nameByLowercase.set(key, entity.name);
+  }
+  for (const entity of extracted.entities) {
+    const key = entity.name.toLowerCase();
+    if (nameByLowercase.has(key)) continue;
+    entities.push({ ...entity, type: normalizeGraphLabel(entity.type, "CONCEPT") });
+    nameByLowercase.set(key, entity.name);
+  }
+  for (const relationship of extracted.relations) {
+    const source = nameByLowercase.get(relationship.source.toLowerCase());
+    const target = nameByLowercase.get(relationship.target.toLowerCase());
+    if (source && target) {
+      relationships.push({
+        ...relationship,
+        source,
+        target,
+        type: normalizeGraphLabel(relationship.type, "RELATED_TO")
+      });
+    }
+  }
+  const seenRelationships = /* @__PURE__ */ new Set();
+  const dedupedRelationships = [];
+  for (const relationship of relationships) {
+    const key = relationshipKey(relationship);
+    if (seenRelationships.has(key)) continue;
+    seenRelationships.add(key);
+    dedupedRelationships.push(relationship);
+  }
+  return { entities, relationships: dedupedRelationships };
+}
+
+// ../shared/src/types/isolation.ts
+var NamespaceIsolation = {
+  SHARED: "shared",
+  STRICT: "strict"
+};
+
+// ../shared/src/types/memory.ts
+var MemoryType = {
+  SHORT_TERM: "short-term",
+  LONG_TERM: "long-term",
+  WORKING: "working",
+  EPISODIC: "episodic",
+  SUMMARY: "summary"
+};
+var SensitivityLevel = {
+  PUBLIC: "public",
+  INTERNAL: "internal",
+  SECRET: "secret"
+};
+var RAGStrategy = {
+  NAIVE: "naive",
+  GRAPH: "graph",
+  HYBRID: "hybrid"
+};
+var DEPRECATED_RAG_STRATEGIES = /* @__PURE__ */ new Map([
+  ["agentic", "strategy.deprecated:agentic \u2014 removed in v0.26, use hybrid"]
+]);
+var VectorProvider = {
+  LANCEDB: "lancedb"
+};
+var EmbeddingProviderName = {
+  STUB: "stub",
+  /** @deprecated Vestigial — pyx-memory uses internal EmbeddingGemma embeddings. */
+  ANTHROPIC: "anthropic",
+  /** @deprecated Vestigial — pyx-memory uses internal EmbeddingGemma embeddings. */
+  OPENAI: "openai",
+  /** In-process ONNX model (default: EmbeddingGemma-300M). */
+  LOCAL: "local",
+  /** Remote OpenAI-compatible embedding service (pyx-cloud shared, custom, etc.). */
+  HTTP: "http"
+};
+var StoreTarget = {
+  SQLITE: "sqlite",
+  VECTOR: "vector",
+  GRAPH: "graph"
+};
+
+// ../shared/src/types/move.ts
+var MoveFailureReason = {
+  /** Entry not found in the caller's tenant. */
+  NOT_FOUND: "not_found",
+  /** Move would cross tenant boundary (always forbidden). */
+  CROSS_TENANT_FORBIDDEN: "cross_tenant_forbidden",
+  /** Target namespace ID does not exist in the caller's tenant. */
+  TARGET_NAMESPACE_NOT_FOUND: "target_namespace_not_found",
+  /** SQLite metadata update failed; no compensation needed. */
+  SQLITE_UPDATE_FAILED: "sqlite_update_failed",
+  /** Vector store metadata update failed; SQLite reverted. */
+  VECTOR_UPDATE_FAILED: "vector_update_failed",
+  /** Graph edge namespace update failed; SQLite + vector reverted. */
+  GRAPH_UPDATE_FAILED: "graph_update_failed",
+  /** Compensation itself failed — manual intervention required. */
+  COMPENSATION_FAILED: "compensation_failed"
+};
+
+// ../shared/src/types/principal.ts
+var SINGLE_TENANT_ID = "_single";
 
 // ../client/src/disabled-memory.ts
 var DEFAULT_PAGE_LIMIT = 20;
@@ -850,6 +972,20 @@ var MemoryClient = class {
 };
 
 export {
+  DEFAULTS,
+  normalizeGraphLabel,
+  normalizeNameKey,
+  mergeExtractedEntities,
+  NamespaceIsolation,
+  MemoryType,
+  SensitivityLevel,
+  RAGStrategy,
+  DEPRECATED_RAG_STRATEGIES,
+  VectorProvider,
+  EmbeddingProviderName,
+  StoreTarget,
+  MoveFailureReason,
+  SINGLE_TENANT_ID,
   DisabledMemory,
   MemoryServerError,
   MemoryClient

package/dist/{chunk-XHEVB23R.mjs → chunk-ML6VKYAL.mjs}

@@ -1,5 +1,5 @@
 // src/contract/index.ts
-var PYX_MEMORY_INSTRUCTIONS = `Use pyx-memory to search durable project/user memory before assuming prior decisions, and to store concise facts after corrections, bug fixes, design decisions, integration discoveries, gotchas, explicit preferences, or "remember this" requests. Store decisions, not deliberation. Include topic and project. Pass eventTime (ISO-8601, when the fact happened or took effect) for any fact that can change or go stale \u2014 job/status changes, decisions that supersede earlier ones, dated events; recency ordering, dated ("as of") queries, and stale-vs-current conflict resolution all key off it. Search effort is retrieval depth: quick=strongest, deep=everything including archived/superseded. Use reinforce after memories were actually used, so they surface in quick/medium effort tiers. Use lineage for the history of how a fact changed; pass subject+relation for graph lineage or entryId for a superseded chain. Use record_correction when the user corrects a mistake you made (what was wrong, what to do instead, when it applies); call fetch_applicable_corrections before a task to retrieve the corrections that match it, then decide which to follow \u2014 pyx never auto-applies them. Isolation: userId/teamId are attribution and legacy filters, not authorization or read gates. Use agentId only for trusted per-agent pool isolation (hard filter when set; omit to share a pool); on hosted MaaS/remote MCP it is a within-tenant filter, not a cross-identity security boundary. For per-user/team privacy inside a shared tenant, use namespaces + ReBAC grants via /api/admin/* + ADMIN_API_KEY + TENANT_MODE=multi. callerAccessLevel is sensitivity redaction, not isolation. Trusted stdio/self-host/companion callers may pass scope per call; hosted MaaS/remote MCP derive identity from project/token and strip caller-supplied identity until verified-JWT multi-tenant remote MCP exists. When a question names a time \u2014 explicit or relative ("last year", "\uB450 \uB2EC \uC804") \u2014 resolve it to an absolute ISO-8601 timestamp yourself and pass it as search anchorTime: results then rank by proximity to this time instead of now, without excluding anything. For count/list questions about a category, pass \`enumerationConcept\` = the language-agnostic/global category phrase (e.g. "fitness classes" / "\uC6B4\uB3D9 \uC218\uC5C5"); the caller-supplied hint is resolved by the embedding model, which covers a broad range of languages. pyx also auto-detects English/Korean count phrasing as a best-effort fallback when the hint is omitted. When content names people, organizations, tools, places, events, or key concepts, pass entities and relationships when you can (caller-wins). You build the graph \u2014 the server does not extract it for you unless a self-host operator has configured a BYO extraction endpoint (then caller-passed graph still wins). On a multi-entity store, include at least one relationship connecting the entities, or the store is refused so isolated nodes never accumulate (set entitiesOnly for a deliberate lone entity); triples make edges impossible to omit. Edges matter as much as nodes: without relationships the graph cannot connect related memories. For countable categories the user may later enumerate ("how many fitness classes / streaming services / pets do I have?"), add a canonical category CONCEPT node and an IS_A edge from each member to it. A language/synonym variant gives zero-cost exact-match resolution only when it is also a memberful CONCEPT node with member IS_A edges; there is no query-time alias\u2192canonical resolver. pyx resolves count/list category hints at query time via strict embedding over memberful CONCEPT nodes. Use file ingest for documents/images worth persisting; images require a description.`;
+var PYX_MEMORY_INSTRUCTIONS = `Use pyx-memory for durable memory across sessions, proactively \u2014 do not wait to be told. SEARCH before assuming: at the start of a task, and before proposing an approach or re-deriving a past decision, search memory for the project and topic; resolve relative times ("last year", "\uB450 \uB2EC \uC804") to an absolute ISO-8601 anchorTime so results rank by proximity to that time. STORE once a fact is settled: corrections, bug fixes (root cause + fix), design/architecture decisions (with reasoning), integration/API/auth/endpoint details, gotchas, explicit preferences, and "remember this" requests \u2014 concise facts not deliberation, each with topic and project. Pass eventTime (ISO-8601, when the fact took effect) for anything that can change or go stale; recency ordering, "as of" queries, and stale-vs-current resolution all key off it. After a memory informs your work, call reinforce so it stays in the quick/medium tiers (idle never revives it). When the user corrects you, call record_correction; before a task, call fetch_applicable_corrections (pyx never auto-applies them). When content names people, organizations, tools, places, events, or key concepts, pass entities and relationships \u2014 you build the graph, the server does not extract it; a multi-entity store with no connecting edge is refused. Match search effort to need: quick (default, strongest) for routine recall, deep for full/archived history; use lineage to trace how a fact changed. userId/teamId/agentId and callerAccessLevel are attribution filters and sensitivity redaction, not a security isolation boundary \u2014 for tenant/namespace/ReBAC detail see the installed Persistent Memory rule.`;
 var PERSISTENT_MEMORY_SECTION = [
   "## Persistent Memory",
   "",
@@ -142,7 +142,8 @@ function buildAgentSnippet() {
     ...targetLines,
     "",
     "Conflict policy:",
-    "- If an existing `Persistent Memory` section references the `pyx-memory` MCP tools, REPLACE it with the version below \u2014 this is the newer canonical rule set for the same system, not a duplicate.",
+    "- If a pyx-memory managed block (between `<!-- pyx-memory:begin \u2026 -->` and `<!-- pyx-memory:end -->`) is already present \u2014 `pyx-mem mcp install` may have written it \u2014 leave it exactly as-is and do NOT add a second copy.",
+    "- Else if an existing `Persistent Memory` section references the `pyx-memory` MCP tools, REPLACE it with the version below \u2014 this is the newer canonical rule set for the same system, not a duplicate.",
     "- If an existing `Persistent Memory` section uses a different memory tool, append this one underneath instead. Do not delete, rewrite, or summarize the other tool's instructions.",
     "",
     "Install only the section below, verbatim. After writing, tell the user which file you updated.",

package/dist/{chunk-3PBLTOBR.mjs → chunk-MZF55IUR.mjs}

@@ -1,6 +1,6 @@
 import {
   MemoryClient
-} from "./chunk-3SDKJ5TB.mjs";
+} from "./chunk-BS6K64SA.mjs";
 
 // ../dashboard/src/aggregations/consolidation-analytics.ts
 function analyzeConsolidationLog(entries) {