@pyxmate/memory 1.17.17 → 1.17.19

package/dist/agent-contract.d.ts

@@ -1,4 +1,5 @@
 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 when durable state settles \u2014 usually before your final response or handoff; if nothing durable changed, store nothing. Otherwise capture a fact (correction, bug fix + root cause, design/architecture decision + reasoning, integration/API/auth/endpoint detail, gotcha, preference, \"remember this\"), a reusable process once stable, a milestone snapshot (type episodic, not a running log), or a changed decision (store the new state with eventTime, never a silent overwrite, so lineage traces it) \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 tenant/namespace isolation is enforced server-side (namespaces + ReBAC grants; see docs/access-control.md).";
+declare const PYX_MEMORY_COMPANION_CORE_INSTRUCTIONS = "Use pyx-memory for durable memory across sessions, proactively \u2014 do not wait to be told. SEARCH (search_memories) before assuming: at the start of a task, and before 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. Match search effort to need: quick (default, strongest) for routine recall, deep for full/archived history. STORE (store_memory) when durable state settles \u2014 usually before your final response; if nothing durable changed, store nothing. Capture concise facts, not deliberation \u2014 a correction, bug fix + root cause, decision + reasoning, integration detail, gotcha, preference, or an explicit \"remember this\" \u2014 each with topic and project. Pass eventTime (ISO-8601, when the fact took effect) for anything that can change or go stale; recency ordering and stale-vs-current resolution key off it. When content names people, organizations, tools, places, events, or key concepts, pass entities and relationships \u2014 you build the graph; a multi-entity store with no connecting edge is refused. Recalled memories reflect what was true when written \u2014 verify named files, flags, and versions before acting.";
 declare const PERSISTENT_MEMORY_SECTION: string;
 declare function buildDesignGuide({ appName }: {
     appName: string;
@@ -37,4 +38,4 @@ declare const STRUCTURE_GRAPH_PROMPT_DESC = "Returns a prompt that extracts the
 declare function buildGraphStructuringPrompt(content: string): string;
 declare function buildAgentSnippet(): string;
 
-export { AGENT_TARGETS, PERSISTENT_MEMORY_SECTION, PYX_MEMORY_INSTRUCTIONS, SEARCH_ENUMERATION_CONCEPT_DESC, SEARCH_LIMIT_DESC, STORE_ENTITIES_DESC, STORE_EVENT_TIME_DESC, STORE_RELATIONSHIPS_DESC, STORE_TOOL_DESC, STORE_TRIPLES_DESC, STRUCTURE_GRAPH_PROMPT_DESC, buildAgentSnippet, buildDesignGuide, buildGraphStructuringPrompt };
+export { AGENT_TARGETS, PERSISTENT_MEMORY_SECTION, PYX_MEMORY_COMPANION_CORE_INSTRUCTIONS, PYX_MEMORY_INSTRUCTIONS, SEARCH_ENUMERATION_CONCEPT_DESC, SEARCH_LIMIT_DESC, STORE_ENTITIES_DESC, STORE_EVENT_TIME_DESC, STORE_RELATIONSHIPS_DESC, STORE_TOOL_DESC, STORE_TRIPLES_DESC, STRUCTURE_GRAPH_PROMPT_DESC, buildAgentSnippet, buildDesignGuide, buildGraphStructuringPrompt };

package/dist/agent-contract.mjs

@@ -1,6 +1,7 @@
 import {
   AGENT_TARGETS,
   PERSISTENT_MEMORY_SECTION,
+  PYX_MEMORY_COMPANION_CORE_INSTRUCTIONS,
   PYX_MEMORY_INSTRUCTIONS,
   SEARCH_ENUMERATION_CONCEPT_DESC,
   SEARCH_LIMIT_DESC,
@@ -13,10 +14,11 @@ import {
   buildAgentSnippet,
   buildDesignGuide,
   buildGraphStructuringPrompt
-} from "./chunk-FQW6BQ2N.mjs";
+} from "./chunk-EZERG25I.mjs";
 export {
   AGENT_TARGETS,
   PERSISTENT_MEMORY_SECTION,
+  PYX_MEMORY_COMPANION_CORE_INSTRUCTIONS,
   PYX_MEMORY_INSTRUCTIONS,
   SEARCH_ENUMERATION_CONCEPT_DESC,
   SEARCH_LIMIT_DESC,

package/dist/{chunk-FQW6BQ2N.mjs → chunk-EZERG25I.mjs}

@@ -1,5 +1,6 @@
 // src/contract/index.ts
 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 when durable state settles \u2014 usually before your final response or handoff; if nothing durable changed, store nothing. Otherwise capture a fact (correction, bug fix + root cause, design/architecture decision + reasoning, integration/API/auth/endpoint detail, gotcha, preference, "remember this"), a reusable process once stable, a milestone snapshot (type episodic, not a running log), or a changed decision (store the new state with eventTime, never a silent overwrite, so lineage traces it) \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 tenant/namespace isolation is enforced server-side (namespaces + ReBAC grants; see docs/access-control.md).`;
+var PYX_MEMORY_COMPANION_CORE_INSTRUCTIONS = `Use pyx-memory for durable memory across sessions, proactively \u2014 do not wait to be told. SEARCH (search_memories) before assuming: at the start of a task, and before 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. Match search effort to need: quick (default, strongest) for routine recall, deep for full/archived history. STORE (store_memory) when durable state settles \u2014 usually before your final response; if nothing durable changed, store nothing. Capture concise facts, not deliberation \u2014 a correction, bug fix + root cause, decision + reasoning, integration detail, gotcha, preference, or an explicit "remember this" \u2014 each with topic and project. Pass eventTime (ISO-8601, when the fact took effect) for anything that can change or go stale; recency ordering and stale-vs-current resolution key off it. When content names people, organizations, tools, places, events, or key concepts, pass entities and relationships \u2014 you build the graph; a multi-entity store with no connecting edge is refused. Recalled memories reflect what was true when written \u2014 verify named files, flags, and versions before acting.`;
 var PERSISTENT_MEMORY_SECTION = [
   "## Persistent Memory",
   "",
@@ -159,6 +160,7 @@ function buildAgentSnippet() {
 
 export {
   PYX_MEMORY_INSTRUCTIONS,
+  PYX_MEMORY_COMPANION_CORE_INSTRUCTIONS,
   PERSISTENT_MEMORY_SECTION,
   buildDesignGuide,
   AGENT_TARGETS,

package/dist/{chunk-JGFDID3B.mjs → chunk-H6ZLMPZH.mjs}

@@ -358,6 +358,15 @@ var MemoryClient = class {
     }
     return headers;
   }
+  exactReadAuthority(namespaceId, authority) {
+    if (namespaceId !== void 0 && authority?.namespaceId !== void 0 && namespaceId !== authority.namespaceId) {
+      throw new Error("X-Namespace-Id conflicts with the request authority scope");
+    }
+    return {
+      ...authority,
+      ...namespaceId !== void 0 ? { namespaceId } : {}
+    };
+  }
   async initialize() {
     const response = await fetch(`${this.baseUrl}/health`, {
       headers: this._authHeaders
@@ -415,7 +424,7 @@ var MemoryClient = class {
     if (params.abstentionThreshold != null)
       searchParams.set("abstentionThreshold", String(params.abstentionThreshold));
     return this.fetchApi(`/api/memory/search?${searchParams}`, {
-      headers: this.authorityHeaders(authority)
+      headers: this.authorityHeaders(this.exactReadAuthority(params.namespaceId, authority))
     });
   }
   async get(id, authority) {
@@ -481,7 +490,7 @@ var MemoryClient = class {
     }
     const qs = searchParams.toString();
     return this.fetchApi(`/api/memory/entries${qs ? `?${qs}` : ""}`, {
-      headers: this.authorityHeaders(authority)
+      headers: this.authorityHeaders(this.exactReadAuthority(params.namespaceId, authority))
     });
   }
   // --- File ingest ---

package/dist/{chunk-AMKPOPH6.mjs → chunk-T35ZOOES.mjs}

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

package/dist/cli/pyx-mem.mjs

@@ -2,7 +2,7 @@
 import {
   PERSISTENT_MEMORY_SECTION,
   buildDesignGuide
-} from "../chunk-FQW6BQ2N.mjs";
+} from "../chunk-EZERG25I.mjs";
 
 // src/cli/exit-codes.ts
 var EXIT = {
@@ -836,7 +836,7 @@ function createProxyServer(client, version, uploadLocalFile) {
   return server;
 }
 async function runMcpProxyServer(opts) {
-  const version = opts.version ?? (true ? "1.17.17" : "0.0.0-dev");
+  const version = opts.version ?? (true ? "1.17.19" : "0.0.0-dev");
   const read = await opts.readCredentials();
   if (!read.ok) {
     const text = read.result.content.map((c) => c.type === "text" ? c.text : "").join(" ").trim();
@@ -1540,6 +1540,147 @@ function resolveMcpMode(flags) {
   return { ok: true };
 }
 
+// src/cli/commands/overview.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import { z } from "zod";
+var OVERVIEW_SCHEMA_VERSION = 1;
+var RECENT_ENTRY_LIMIT = 3;
+var MAX_TOPIC_CHARS = 160;
+var MAX_PROJECT_CHARS = 80;
+var entrySchema = z.object({
+  id: z.string().min(1),
+  metadata: z.record(z.string(), z.unknown())
+}).passthrough();
+var hostedEntriesResponseSchema = z.object({
+  memories: z.array(entrySchema),
+  total: z.number().int().nonnegative()
+}).passthrough();
+var selfHostedEntriesResponseSchema = z.object({
+  success: z.literal(true),
+  data: z.object({
+    entries: z.array(entrySchema),
+    totalCount: z.number().int().nonnegative()
+  }).passthrough()
+}).passthrough();
+var entriesResponseSchema = z.union([
+  hostedEntriesResponseSchema.transform(({ memories, total }) => ({
+    entries: memories,
+    totalCount: total
+  })),
+  selfHostedEntriesResponseSchema.transform(({ data }) => data)
+]);
+async function overviewCommand(opts = {}) {
+  const provider = opts.keychain ?? getDefaultKeychain();
+  let credentials;
+  try {
+    credentials = await provider.read();
+  } catch (error) {
+    const detail = error instanceof KeychainError ? [error.message, error.guidance].filter(Boolean).join(" ") : "The OS credential store could not be read.";
+    emit(report("error", null, null, detail));
+    return error instanceof KeychainError ? error.exit : EXIT.CRED_UNAVAILABLE;
+  }
+  if (!credentials) {
+    emit(report("signed_out", null, null, null));
+    return EXIT.NOT_LOGGED_IN;
+  }
+  if (!isHttpUrl2(credentials.endpoint)) {
+    emit(
+      report(
+        "error",
+        null,
+        "keychain",
+        "The stored pyx-memory endpoint is invalid. Run: pyx-mem login"
+      )
+    );
+    return EXIT.DOCTOR_FAIL;
+  }
+  const http = createHttpClient(credentials, opts.fetchImpl ?? fetch);
+  const response = await http.requestJson({
+    method: "GET",
+    path: "/api/memory/entries",
+    query: { status: "active", limit: RECENT_ENTRY_LIMIT },
+    idempotencyKey: `cli-overview-${randomUUID3()}`
+  });
+  if (!response.ok) {
+    const signedOut = response.status === 401;
+    emit(
+      report(
+        signedOut ? "signed_out" : "error",
+        credentials.endpoint,
+        "keychain",
+        overviewFailure(response.status)
+      )
+    );
+    return signedOut ? EXIT.NOT_LOGGED_IN : EXIT.DOCTOR_FAIL;
+  }
+  const parsed = entriesResponseSchema.safeParse(response.data);
+  if (!parsed.success) {
+    emit(
+      report(
+        "error",
+        credentials.endpoint,
+        "keychain",
+        "pyx-memory returned an invalid overview response. Run: pyx-mem doctor"
+      )
+    );
+    return EXIT.DOCTOR_FAIL;
+  }
+  emit({
+    ...report("ready", credentials.endpoint, "keychain", null),
+    totalCount: parsed.data.totalCount,
+    entries: parsed.data.entries.slice(0, RECENT_ENTRY_LIMIT).map((entry) => ({
+      id: entry.id,
+      topic: boundedLabel(entry.metadata.topic, "Untitled", MAX_TOPIC_CHARS),
+      project: boundedLabel(entry.metadata.project, "Unscoped", MAX_PROJECT_CHARS)
+    }))
+  });
+  return EXIT.OK;
+}
+function report(state, endpoint, keySource, problem) {
+  return {
+    schemaVersion: OVERVIEW_SCHEMA_VERSION,
+    state,
+    endpoint,
+    keySource,
+    totalCount: 0,
+    entries: [],
+    problem
+  };
+}
+function emit(value) {
+  process.stdout.write(`${JSON.stringify(value)}
+`);
+}
+function overviewFailure(status) {
+  if (status === 401) {
+    return "Stored pyx-memory credentials were rejected. Run: pyx-mem login";
+  }
+  if (status === 403) {
+    return "pyx-memory denied access (HTTP 403). Check the key scope and project access.";
+  }
+  if (status === void 0) {
+    return "Unable to reach pyx-memory. Run: pyx-mem doctor";
+  }
+  if (status >= 500) {
+    return `pyx-memory is unavailable (HTTP ${status}). Run: pyx-mem doctor`;
+  }
+  return `pyx-memory overview failed (HTTP ${status}). Run: pyx-mem doctor`;
+}
+function boundedLabel(value, fallback, maxChars) {
+  if (typeof value !== "string" || value.trim().length === 0) return fallback;
+  const normalized = value.trim();
+  const chars = [...normalized];
+  return chars.length > maxChars ? `${chars.slice(0, maxChars).join("")}\u2026` : normalized;
+}
+function isHttpUrl2(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === "http:" || url.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+
 // src/cli/commands/scaffold.ts
 import { existsSync as existsSync4, mkdirSync as mkdirSync3, statSync as statSync2, writeFileSync as writeFileSync3 } from "fs";
 import { basename as basename2, join as join2, resolve as resolve2 } from "path";
@@ -1720,10 +1861,10 @@ function scaffoldCommand(args = {}) {
 // src/cli/commands/status.ts
 async function statusCommand(opts = {}) {
   const provider = opts.keychain ?? getDefaultKeychain();
-  let report;
+  let report2;
   try {
     const creds = await provider.read();
-    report = {
+    report2 = {
       endpoint: creds?.endpoint ?? null,
       keyPresent: creds !== null,
       keySource: creds !== null ? "keychain" : null,
@@ -1734,17 +1875,17 @@ async function statusCommand(opts = {}) {
     throw err;
   }
   if (opts.json) {
-    process.stdout.write(`${JSON.stringify(report)}
+    process.stdout.write(`${JSON.stringify(report2)}
 `);
   } else {
     const lines = [
-      `endpoint:    ${report.endpoint ?? "(not set)"}`,
-      `credentials: ${report.loggedIn ? "present (keychain)" : "not logged in \u2014 run: pyx-mem login"}`
+      `endpoint:    ${report2.endpoint ?? "(not set)"}`,
+      `credentials: ${report2.loggedIn ? "present (keychain)" : "not logged in \u2014 run: pyx-mem login"}`
     ];
     process.stdout.write(`${lines.join("\n")}
 `);
   }
-  return report.loggedIn ? EXIT.OK : EXIT.NOT_LOGGED_IN;
+  return report2.loggedIn ? EXIT.OK : EXIT.NOT_LOGGED_IN;
 }
 function emitError(err, json) {
   if (json) {
@@ -1769,6 +1910,7 @@ Usage:
 Commands:
   login [--endpoint <url>] [--api-key <key>]   Store endpoint and API key in OS credential store.
   status [--json]                              Show endpoint, key presence, MCP config status.
+  overview --json                              Read memory count and three recent safe labels.
   logout                                       Delete stored pyx-memory credentials.
   doctor [--json]                              Diagnose keychain, credentials, backend, MCP startup.
   scaffold [--name <dir>]                      Generate Docker, env, SDK, and memory design-guide starter files.
@@ -1915,6 +2057,12 @@ async function main() {
       });
     case "status":
       return statusCommand({ json: parsed.flags.json === true });
+    case "overview":
+      if (parsed.flags.json !== true) {
+        process.stderr.write("Error: `pyx-mem overview` requires --json.\n");
+        return EXIT.USAGE;
+      }
+      return overviewCommand();
     case "logout":
       return logoutCommand();
     case "doctor":
@@ -1932,10 +2080,10 @@ async function main() {
   }
 }
 main().then((code) => {
-  process.exit(code);
+  process.exitCode = code;
 }).catch((err) => {
   const msg = err instanceof Error ? err.message : String(err);
   process.stderr.write(`Internal error: ${msg}
 `);
-  process.exit(1);
+  process.exitCode = 1;
 });

package/dist/dashboard.mjs

@@ -11,8 +11,8 @@ import {
   toGraphologyFormat,
   transformGraphData,
   unreachableHealth
-} from "./chunk-AMKPOPH6.mjs";
-import "./chunk-JGFDID3B.mjs";
+} from "./chunk-T35ZOOES.mjs";
+import "./chunk-H6ZLMPZH.mjs";
 import "./chunk-3OLH3HYR.mjs";
 export {
   DashboardClient,

package/dist/index.d.ts

@@ -28,6 +28,8 @@ interface MemoryListParams {
     agentId?: string;
     /** Filter by tenant ID for multi-tenant isolation. */
     tenantId?: string;
+    /** Exact namespace scope. Excludes legacy tenant-root entries. */
+    namespaceId?: string;
     /**
      * Calling principal. When supplied, list applies the AuthzPlan
      * visibility filter so entries in forbidden namespaces never reach
@@ -385,9 +387,10 @@ declare class MemoryClient implements ExtendedMemoryInterface {
     /** Encode a path segment to prevent URL injection */
     private encodePathSegment;
     private authorityHeaders;
+    private exactReadAuthority;
     initialize(): Promise<void>;
     store(entry: StoreInput$1, options?: StoreOptions): Promise<MemoryEntry$1>;
-    search(params: MemorySearchParams$1, authority?: RequestAuthorityOptions): Promise<MemorySearchResult$1>;
+    search(params: MemorySearchParams$1, authority?: RequestAuthorityOptions & Pick<TenantScopeOptions, 'tenantId' | 'namespaceId'>): Promise<MemorySearchResult$1>;
     get(id: string, authority?: TenantScopeOptions & RequestAuthorityOptions): Promise<MemoryEntry$1 | null>;
     delete(id: string, authority?: TenantScopeOptions & RequestAuthorityOptions): Promise<boolean>;
     clearSession(sessionId: string): Promise<number>;
@@ -403,7 +406,7 @@ declare class MemoryClient implements ExtendedMemoryInterface {
      */
     status(): Promise<Topology$1>;
     shutdown(): Promise<void>;
-    list(params?: MemoryListParams, authority?: RequestAuthorityOptions): Promise<MemoryListResult>;
+    list(params?: MemoryListParams, authority?: RequestAuthorityOptions & Pick<TenantScopeOptions, 'tenantId' | 'namespaceId'>): Promise<MemoryListResult>;
     /**
      * Native streaming file ingest. Yields typed {@link IngestEvent}s as the
      * server (parsing/storing) and the SDK (enrichment/result) make progress.
@@ -921,6 +924,12 @@ interface MemorySearchParams {
     userId?: string;
     /** Team/group ID within the tenant. */
     teamId?: string;
+    /**
+     * Exact namespace requested by a trusted transport boundary. `Memory.search`
+     * validates it against the calling principal's AuthzPlan and compiles it to
+     * a singleton prefilter. Exact scope excludes legacy NULL rows.
+     */
+    namespaceId?: string;
     /**
      * AuthzPlan-derived visibility list. Populated internally by `Memory.search`
      * after computing the plan from the calling principal — callers should
@@ -928,15 +937,11 @@ interface MemorySearchParams {
      * legacy NULL-namespace entries are visible). `undefined` skips the
      * filter (single-tenant / pre-ReBAC compat).
      *
-     * "Search within this specific folder" UX is intentionally NOT supported
-     * via a singular `namespaceId` field for v1 — adding it would force
-     * intersection logic with the visibility list (and confused-deputy risk
-     * if the singular value isn't validated against the plan). Callers that
-     * need it can compute the singleton intersection client-side and pass
-     * `namespaceIds: [chosenNamespace]` after verifying access via the
-     * admin API.
+     * Callers must not set this directly; use `namespaceId` for exact scope.
      */
     namespaceIds?: string[];
+    /** Strict namespace equality compiled internally from `namespaceId`. */
+    exactNamespaceId?: string;
     /**
      * AuthzPlan-derived list of strict-mode namespaces in the caller's
      * tenant the principal CANNOT see (v0.17.0). Graph traversal MUST

package/dist/index.mjs

@@ -21,7 +21,7 @@ import {
   secretElevationAggregate,
   secretElevationNoticeFor,
   withSecretElevationNotice
-} from "./chunk-JGFDID3B.mjs";
+} from "./chunk-H6ZLMPZH.mjs";
 import {
   assertGraphExtractionPayload,
   encodeListCursorToken,

package/dist/react.mjs

@@ -11,8 +11,8 @@ import {
   toGraphologyFormat,
   transformGraphData,
   unreachableHealth
-} from "./chunk-AMKPOPH6.mjs";
-import "./chunk-JGFDID3B.mjs";
+} from "./chunk-T35ZOOES.mjs";
+import "./chunk-H6ZLMPZH.mjs";
 import "./chunk-3OLH3HYR.mjs";
 
 // ../dashboard/src/hooks/use-consolidation-log.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pyxmate/memory",
-  "version": "1.17.17",
+  "version": "1.17.19",
   "type": "module",
   "description": "SDK for pyx-memory — Memory as a Service for AI agents",
   "license": "MIT",