json-object-editor 0.10.506 → 0.10.508

package/CHANGELOG.md

@@ -1,5 +1,18 @@
+## 0.10.508
+
+- Saves: `saveObject` assigns an `_id` if missing (prefers `cuid()`, fallback `$c.guid()`), ensuring history consistency
+
 ## CHANGELOG
 
+
+### 0.10.507
+
+- Server: Added fuzzy search support via `$fuzzy` in `JOE.Cache.search(query)` with weighted default fields (name 0.6, info 0.3, description 0.1). Implemented a lightweight trigram Jaccard scorer. Supports `q`, `fields`, `threshold`, `limit`, `offset`, `highlight`, `minQueryLength`.
+- API: `/API/search` now safely parses JSON (no eval), and accepts `mode=fuzzy` plus query params (`q`, `fields`, `threshold`, `limit`, `offset`, `highlight`). Backward compatible; exact search remains default.
+- MCP: New tool `fuzzySearch` for typo-tolerant free text across weighted fields; updated `search` description to clarify exact vs fuzzy usage.
+- Docs: Updated README with fuzzy API and MCP usage examples.
+
+
 ### 0.10.500
 	500 - MCP integration (initial)
 	- MCP core module with JSON-RPC 2.0 endpoint (/mcp) protected by auth

package/_www/mcp-prompt.html

@@ -15,15 +15,129 @@
     <script src="/JsonObjectEditor/_www/mcp-nav.js"></script>
     <h1>Starter Agent Instructions</h1>
     <div class="small">Copy into your Custom GPT or Assistant system prompt. Adjust as needed.</div>
-    <textarea readonly id="prompt"></textarea>
-    <script>
-    (function(){
-        const text = [
-`You are a data assistant for JOE. Use only the provided tools.\n\nAutonomy:\n- Act autonomously; if a tool can answer, call it immediately (no permission prompts).\n- Do not offer multiple-choice options; pick the best action.\n- Ask one brief clarification only if a required parameter is missing.\n- On a new session: call hydrate {} first, then proceed.\n- Keep results scoped (limit 10–25). Flatten is optional and off by default; enable only when needed.\n- Never expose secrets/tokens. Confirm with the user before saveObject.\n\nTypical flow:\n- listSchemas {}, getSchema { "name": "<schema>" }\n- search { "query": { "itemtype": "<schema>" }, "limit": 10 } (cache) or { "source": "storage" } for authoritative results\n- getObject { "_id": "<id>", "schema": "<schema>" }\n- saveObject { "object": { ... } } only on explicit user request\n\nExamples:\n- listSchemas {}\n- getSchema { "name": "client" }\n- search { "schema": "client", "source": "storage", "query": { "status": "active" }, "limit": 10 }\n- getObject { "_id": "123", "schema": "client" }`
-        ].join('\n');
-        document.getElementById('prompt').value = text;
-    })();
-    </script>
+    <textarea readonly id="prompt">You are a schema-aware data assistant for JOE. Use only the provided tools.
+
+👩‍💻 Dev Mode Behavior:
+If `devMode` is true, narrate your actions as you go (e.g., "Calling getSchema for 'client'...").
+
+🎯 Autonomy:
+- Act autonomously — call tools immediately if you know what’s needed.
+- No permission prompts, no menus — pick the best action.
+- Ask for clarification only if a required parameter is missing.
+- On session start: `hydrate {}`, then preload schemas.
+- Never expose secrets/tokens. Always confirm before `saveObject`.
+
+🧠 Schema Awareness:
+- Always hydrate first (`hydrate {}`), then `listSchemas` + `getSchema` for each.
+- Keep a `schemaMap` in memory for validation.
+- Validate fields before constructing objects or saving.
+
+🔍 Query Strategy:
+- Default: `search { "query": { "itemtype": "<schema>" }, "limit": 10 }`
+- For authoritative data: add `"source": "storage"`
+- For large queries: `search { countOnly: true }` first
+- Use filters to narrow results; paginate when over 25.
+
+📦 References:
+- References are always string IDs.
+- Use `getObject` to resolve related objects.
+- Never assume a reference includes a name/label.
+
+📘 Object Flow:
+- `getObject { _id, schema }` → returns raw object
+- `saveObject { object }` → only on explicit instruction
+- Always reflect the final object before saving; confirm fields match schema
+
+🚀 Typical Sequence:
+1. `hydrate {}`
+2. `listSchemas {}`
+3. For each needed schema: `getSchema { name }`
+4. `search { query: { itemtype }, limit: 10 }`
+5. `getObject { _id, schema }` (if user selects)
+6. `saveObject { object }` (only after confirmation)
+
+🔒 Save Behavior:
+- Never auto-save
+- Confirm with user
+- Ensure object has `itemtype` and only valid fields
+(see FULL OBJECT SAVE REQUIREMENT)
+
+
+Summary (Tips for Success)
+The agent identifies users by ID before querying, handles large payloads automatically, and if searches fail, it retrieves a cached list of records and filters them locally. It prefers cache for efficiency and only queries storage when up-to-date data is essential. All read operations run autonomously, while write actions (like saves) always require user confirmation. The agent retries gracefully on errors and prioritizes data integrity over speed.
+
+🧠 Tips for Success
+
+1. Identify the User by ID First
+Before making any queries, retrieve the user’s _id from the user schema using name, username, or email.
+Use that ID for all task, project, or goal lookups.
+
+2. Handle Large Payloads Automatically
+If a query risks exceeding limits or triggers a ResponseTooLargeError, immediately retry with "countOnly": true to assess scope.
+Then paginate (25–50 items) or filter (e.g., overdue, recent).
+
+3. Fallback When Search Returns No Results
+If a search returns no results, retrieve a broad list of items from cache (for example, limit: 200, source: "cache"). Then perform the matching or filtering locally within the agent rather than re-querying MongoDB. This allows for flexible, fuzzy, or partial matching when records use slightly different names or labels. Use cached data whenever possible to reduce database load and latency.
+
+4. Prefer Cached Results Unless Accuracy Requires Storage
+Use "source": "cache" by default for most queries to reduce database load.
+Only use "source": "storage" when authoritative, up-to-date data is essential (e.g., post-save validations).
+
+5. Graceful Degradation
+When tool calls fail or responses are truncated, automatically reduce depth, limit, or flatten and retry.
+Always return partial results with context rather than halting.
+(see hydration utilization)
+
+6. Resolve References Contextually
+When referencing linked data (projects, businesses, etc.), resolve the _id via schema lookup first.
+Never assume a reference includes the name or label directly.
+
+💧 Hydration Utilization
+
+Hydration provides preloaded datasets such as status, tag, dataset, and other shared entities.
+These hydrated objects should always be used first when resolving references or labels before performing new searches.
+
+When the agent needs a status, tag, or other labeling entity, it should:
+
+Check the hydrated cache (for example, _joe.Data.status, _joe.Data.tag) for matches.
+
+Filter by datasets that include the relevant schema, such as "task" or "project".
+
+Use the hydrated record’s _id directly when creating or linking new objects.
+
+Only query storage if the hydration cache is missing or incomplete.
+
+This approach ensures accuracy and performance by aligning all lookups with canonical, workflow-defined entities already present in memory.
+
+
+
+AUTONOMY & SAFETY
+
+Autonomous Read Operations
+The agent acts independently for all read-only actions. It should execute hydrate, listSchemas, getSchema, search (cache or storage), getObject, count, and any fallback pagination or list retrieval without asking for user confirmation. These operations are non-destructive and safe for full autonomy.
+
+Explicit Confirmation for Writes
+Any operation that modifies or creates data must be confirmed by the user before execution. This includes saveObject or any update or creation that writes to storage. Before saving, validate the object against its schema and reflect it back to the user for confirmation.
+
+Fail-Safe Execution
+If a tool call fails, retry safely by reducing depth or limit, or switching to cache. Never guess or infer field values or relationships. Always prioritize data integrity over speed for write operations.
+
+
+FULL OBJECT SAVE REQUIREMENT
+
+When performing a saveObject operation, always include the complete object rather than only the updated fields. Partial updates are not supported by the JOE MCP interface and will fail validation.
+
+Before saving:
+
+- Retrieve the latest version of the object from storage using getObject.
+- Merge any updates into that object in memory.
+- Ensure the itemtype, _id, and all schema-required fields are present.
+- Update the joeUpdated field to the current UTC time in ISO 8601 format with milliseconds.
+- Validate that all field types (for example, priority as a string, date fields in ISO format, booleans for completion) match the schema.
+- Save the complete object back using saveObject.
+
+Why this matters:
+The JOE MCP interface replaces the full document on save rather than applying a patch. If required fields or key metadata (such as itemtype or project references) are missing, the record can become invalid or incomplete. Full-object saves guarantee schema integrity, consistent relationships, and a complete audit trail.</textarea>
 </body>
 </html>
 

package/_www/mcp-test.html

@@ -14,6 +14,7 @@
 		.small{font-size:12px;color:#666}
 		.bad{color:#b00020}
 		.good{color:#0a7d00}
+		.preset{margin:8px 0;}
 	</style>
 </head>
 <body>
@@ -33,6 +34,12 @@
 	<select id="tool"></select>
 	<pre id="toolInfo"></pre>
 	
+	<h3>Presets</h3>
+	<div class="preset">
+		<button id="presetFuzzyUser">fuzzySearch users: q="corey hadden"</button>
+		<button id="presetFuzzyHouse">fuzzySearch houses: q="backyard"</button>
+	</div>
+	
 	<h3>Call JSON-RPC</h3>
 	<label for="params">Params (JSON)</label>
 	<textarea id="params">{}</textarea>
@@ -54,6 +61,8 @@
 		const callBtn = $('call');
 		const callStatus = $('callStatus');
 		const result = $('result');
+		const presetFuzzyUser = $('presetFuzzyUser');
+		const presetFuzzyHouse = $('presetFuzzyHouse');
 		
 		// Try to infer base from window location
 		base.value = base.value || (location.origin);
@@ -84,8 +93,8 @@
 			try{
 				const url = base.value.replace(/\/$/,'') + '/.well-known/mcp/manifest.json';
 				manifest = await fetchJSON(url);
-                // Instance info handled by shared nav script
-                (manifest.tools||[]).forEach(t=>{
+	            // Instance info handled by shared nav script
+	            (manifest.tools||[]).forEach(t=>{
 					const opt=document.createElement('option');
 					opt.value=t.name; opt.textContent=t.name;
 					toolSel.appendChild(opt);
@@ -114,6 +123,16 @@
 		}
 		toolSel.onchange = renderToolInfo;
 
+		presetFuzzyUser.onclick = function(){
+			toolSel.value = 'fuzzySearch';
+			renderToolInfo();
+			params.value = JSON.stringify({ q: 'corey hadden', filters: { itemtype: 'user' }, threshold: 0.5 }, null, 2);
+		};
+		presetFuzzyHouse.onclick = function(){
+			toolSel.value = 'fuzzySearch';
+			renderToolInfo();
+			params.value = JSON.stringify({ q: 'backyard', filters: { itemtype: 'house' }, threshold: 0.5 }, null, 2);
+		};
 		
 		callBtn.onclick = async function(){
 			setStatus(callStatus, 'Calling...', null);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-object-editor",
-  "version": "0.10.506",
+  "version": "0.10.508",
   "description": "JOE the Json Object Editor | Platform Edition",
   "main": "app.js",
   "scripts": {

package/readme.md

@@ -45,9 +45,13 @@ JOE is software that allows you to manage data models via JSON objects. There ar
 - Tools
   - `listSchemas(name?)`, `getSchema(name)`
   - `getObject(_id, schema?)` (supports optional `flatten` and `depth`)
-  - `search` (preferred): unified tool for cache and storage
+  - `search` (exact): unified tool for cache and storage
     - Params: `{ schema?, query?, ids?, source?: 'cache'|'storage', limit?, flatten?, depth? }`
-    - Defaults to cache across all collections; add `schema` to filter; set `source:"storage"` to query a specific schema in the DB.
+    - Defaults to cache across all collections; add `schema` to filter; set `source:"storage"` to query a specific schema in the DB. Use `fuzzySearch` for typo-tolerant free text.
+  - `fuzzySearch` (typo-tolerant free text across weighted fields)
+    - Params: `{ schema?, q, filters?, fields?, threshold?, limit?, offset?, highlight?, minQueryLength? }`
+    - Defaults: `fields` resolved from schema `searchables` (plural) if present; otherwise weights `name:0.6, info:0.3, description:0.1`. `threshold:0.5`, `limit:50`, `minQueryLength:2`.
+    - Returns: `{ items, count }`. Each item may include `_score` (0..1) and `_matches` when `highlight` is true.
   - `saveObject({ object })`
 
 - Quick tests (PowerShell)
@@ -76,6 +80,11 @@ JOE is software that allows you to manage data models via JSON objects. There ar
     $body = @{ jsonrpc="2.0"; id="3"; method="search"; params=@{ query=@{ itemtype="<schemaName>" }; limit=10 } } | ConvertTo-Json -Depth 10
     Invoke-RestMethod -Method Post -Uri "$base/mcp" -Headers $h -Body $body
     ```
+  - fuzzySearch (cache):
+    ```powershell
+    $body = @{ jsonrpc="2.0"; id="6"; method="fuzzySearch"; params=@{ schema="<schemaName>"; q="st paal"; threshold=0.35; limit=10 } } | ConvertTo-Json -Depth 10
+    Invoke-RestMethod -Method Post -Uri "$base/mcp" -Headers $h -Body $body
+    ```
   - search (storage):
     ```powershell
     $body = @{ jsonrpc="2.0"; id="4"; method="search"; params=@{ schema="<schemaName>"; source="storage"; query=@{ }; limit=10 } } | ConvertTo-Json -Depth 10
@@ -105,6 +114,12 @@ JOE is software that allows you to manage data models via JSON objects. There ar
       -H 'Content-Type: application/json' \
       -d '{"jsonrpc":"2.0","id":"3","method":"search","params":{"query":{"itemtype":"<schemaName>"},"limit":10}}' | jq
     ```
+  - fuzzySearch:
+    ```bash
+    curl -s -X POST http://localhost:<PORT>/mcp \
+      -H 'Content-Type: application/json' \
+      -d '{"jsonrpc":"2.0","id":"6","method":"fuzzySearch","params":{"schema":"<schemaName>","q":"st paal","threshold":0.35,"limit":10}}' | jq
+    ```
   - search (storage):
     ```bash
     curl -s -X POST http://localhost:<PORT>/mcp \

package/server/config/ai-global.json

@@ -0,0 +1,34 @@
+{
+	"ai_global_instructions": {
+		"save_strategy": "full_object",
+		"save_steps": [
+			"Retrieve latest object with getObject",
+			"Merge updates in memory",
+			"Ensure all required fields are included",
+			"Set joeUpdated to current UTC ISO8601 (with milliseconds)",
+			"Save using saveObject"
+		],
+		"timestamps": {
+			"update_field": "joeUpdated",
+			"format": "ISO8601_with_milliseconds"
+		},
+		"search_behavior": {
+			"default_source": "cache",
+			"when_to_use_storage": "after saves or when authoritative",
+			"fallback_strategy": "list_and_filter_locally"
+		},
+		"hydration": {
+			"required": true,
+			"datasets": [
+				"status",
+				"tag",
+				"dataset",
+				"user"
+			]
+		},
+		"protection_handling": {
+			"_protected": "restrict access to assigned members or admins"
+		}
+	}
+}
+

package/server/modules/Cache.js

@@ -67,10 +67,186 @@ function Cache(updateNow) {
     this.search = function(query){
         //gets a search query and finds within all items
         //TODO: cache queries
-        
-       // var results = self.list.where(query);
-       // logit(query,results);
-        return self.list.where(query);
+
+        try{
+            if (!query) { return self.list || []; }
+            // Fuzzy search path: query contains $fuzzy
+            if (query.$fuzzy) {
+                var specs = query.$fuzzy || {};
+                var exact = {};
+                for (var k in query) { if (k !== '$fuzzy') { exact[k] = query[k]; } }
+                var candidates = (self.list || []).where(exact || {});
+                return self.fuzzySearch(candidates, specs);
+            }
+            // Default exact/where
+            return (self.list || []).where(query);
+        }catch(e){
+            console.log(JOE.Utils.color('[cache]','error')+' error in search: '+e);
+            return [];
+        }
+    }
+
+    // Compute fuzzy similarity across weighted fields with simple trigram Jaccard
+    this.fuzzySearch = function(items, specs){
+        try{
+            var arr = Array.isArray(items) ? items : (items ? [items] : []);
+            var q = (specs && specs.q) || '';
+            var threshold = (typeof specs.threshold === 'number') ? specs.threshold : 0.5;
+            var limit = (typeof specs.limit === 'number') ? specs.limit : 50;
+            var offset = (typeof specs.offset === 'number') ? specs.offset : 0;
+            var highlight = !!specs.highlight;
+            var minQLen = (typeof specs.minQueryLength === 'number') ? specs.minQueryLength : 2;
+            if (!q || (q+'').length < minQLen) { return []; }
+
+            var resolvedFieldsCache = {};
+
+            function norm(s){
+                try{
+                    if (s == null) { return ''; }
+                    var str = (typeof s === 'string') ? s : (Array.isArray(s) ? s.join(' ') : (typeof s === 'object' ? JSON.stringify(s) : (s+'')));
+                    str = (str+'' ).toLowerCase();
+                    // collapse and trim whitespace so blank/space-only fields don't falsely match
+                    str = str.replace(/\s+/g,' ').trim();
+                    try { str = str.normalize('NFD').replace(/\p{Diacritic}/gu, ''); } catch(_e) {}
+                    return str;
+                }catch(e){ return (s+'' ).toLowerCase(); }
+            }
+
+            function trigrams(s){
+                var set = {};
+                for (var i=0;i<=s.length-3;i++){ set[s.substr(i,3)] = true; }
+                return set;
+            }
+            function jaccard(a,b){
+                if (!a || !b) { return 0; }
+                // Direct substring containment is strongest
+                if (a.indexOf(b) !== -1 || b.indexOf(a) !== -1) { return 1; }
+                // For very short strings, require exact if not contained
+                if (a.length < 3 || b.length < 3){ return (a === b) ? 1 : 0; }
+                var A = trigrams(a), B = trigrams(b);
+                var i=0, u=0, aSize=0;
+                var key;
+                for (key in A){ if (A.hasOwnProperty(key)) { aSize++; if (B[key]) { i++; } u++; } }
+                for (key in B){ if (B.hasOwnProperty(key) && !A[key]) { u++; } }
+                var jac = u ? (i/u) : 0;
+                var containment = aSize ? (i/aSize) : 0; // how much of query's trigrams are in field
+                return Math.max(containment, jac);
+            }
+
+            function getByPath(obj, path){
+                try{
+                    if (!path) return undefined;
+                    var parts = (path+'').split('.');
+                    var cur = obj;
+                    for (var i=0;i<parts.length;i++){
+                        if (cur == null) return undefined;
+                        cur = cur[parts[i]];
+                    }
+                    return cur;
+                }catch(e){ return undefined; }
+            }
+
+            function normalizeFieldDefs(fieldDefs, fromSchema){
+                // Accept ["name", {path:"info", weight:0.3}] or already-normalized
+                var defs = [];
+                var total = 0;
+                var i;
+                for (i=0;i<(fieldDefs||[]).length;i++){
+                    var f = fieldDefs[i];
+                    if (typeof f === 'string') { defs.push({ path:f, weight:0 }); }
+                    else if (f && f.path) { defs.push({ path:f.path, weight: typeof f.weight==='number'? f.weight : 0 }); }
+                }
+                // If coming from schema and no explicit weights provided, assign equal weights
+                if (fromSchema === true){
+                    var anyWeighted = defs.some(function(d){ return typeof d.weight === 'number' && d.weight > 0; });
+                    if (!anyWeighted && defs.length){
+                        var eq = 1 / defs.length;
+                        return defs.map(function(d){ return { path:d.path, weight:eq }; });
+                    }
+                }
+                // Apply default weights for known fields; distribute remaining equally across those still zero
+                var DEFAULTS = { name:0.6, info:0.3, description:0.1 };
+                for (i=0;i<defs.length;i++){
+                    var key = (defs[i].path||'').split('.')[0];
+                    if (defs[i].weight === 0 && DEFAULTS.hasOwnProperty(key)){
+                        defs[i].weight = DEFAULTS[key];
+                    }
+                }
+                total = defs.reduce(function(sum,d){ return sum + (d.weight||0); }, 0);
+                var zeros = defs.filter(function(d){ return !d.weight; });
+                var remaining = Math.max(0, 1 - total);
+                if (zeros.length && remaining > 0){
+                    var each = remaining / zeros.length;
+                    zeros.map(function(d){ d.weight = each; });
+                    total = 1;
+                }
+                if (total === 0){
+                    // No weights assigned: fall back to defaults trio
+                    return [ {path:'name', weight:0.6}, {path:'info', weight:0.3}, {path:'description', weight:0.1} ];
+                }
+                // Normalize to sum=1
+                defs = defs.map(function(d){ return { path:d.path, weight: d.weight/total }; });
+                return defs;
+            }
+
+            function resolveFieldsForItem(item, explicitFields){
+                if (explicitFields && explicitFields.length){ return normalizeFieldDefs(explicitFields, false); }
+                var it = item && item.itemtype;
+                if (resolvedFieldsCache[it]) { return resolvedFieldsCache[it]; }
+                var def = (JOE && JOE.Schemas && JOE.Schemas.schema && JOE.Schemas.schema[it]) || {};
+                var fields = [];
+                if (Array.isArray(def.searchables)){
+                    resolvedFieldsCache[it] = normalizeFieldDefs(def.searchables, true);
+                    return resolvedFieldsCache[it];
+                }
+                // Default trio
+                resolvedFieldsCache[it] = [ {path:'name', weight:0.6}, {path:'info', weight:0.3}, {path:'description', weight:0.1} ];
+                return resolvedFieldsCache[it];
+            }
+
+            var nq = norm(q);
+            var scored = [];
+            var useWeighted = Array.isArray(specs && specs.fields) && (specs.fields.length > 0);
+            for (var idx=0; idx<arr.length; idx++){
+                var item = arr[idx];
+                if (!item) { continue; }
+                var fields = resolveFieldsForItem(item, specs && specs.fields);
+                var score = 0;
+                var best = 0;
+                var matches = [];
+                for (var f=0; f<fields.length; f++){
+                    var fd = fields[f];
+                    var val = getByPath(item, fd.path);
+                    var s = norm(val);
+                    if (!s) { continue; }
+                    var sim = jaccard(s, nq);
+                    // aggregate
+                    score += (fd.weight||0) * sim;
+                    if (sim > best) { best = sim; }
+                    if (highlight && sim > 0){
+                        var ix = s.indexOf(nq);
+                        if (ix !== -1){ matches.push({ field: fd.path, indices: [[ix, ix + nq.length - 1]] }); }
+                    }
+                }
+                var finalScore = useWeighted ? score : best;
+                if (finalScore >= threshold){
+                    var out = Object.assign({}, item);
+                    out._score = +finalScore.toFixed(6);
+                    if (highlight && matches.length){ out._matches = matches; }
+                    scored.push(out);
+                }
+            }
+            scored.sort(function(a,b){ return (b._score||0) - (a._score||0); });
+            var totalCount = scored.length;
+            if (offset && offset > 0) { scored = scored.slice(offset); }
+            if (limit && limit > 0) { scored = scored.slice(0, limit); }
+            // Attach count to a non-invasive property if array consumer needs it (not altering API here)
+            scored.count = totalCount;
+            return scored;
+        }catch(e){
+            console.log(JOE.Utils.color('[cache]','error')+' error in fuzzySearch: '+e);
+            return [];
+        }
     }
     this.findByID = function(collection,id,specs,returnProp){
         try{

package/server/modules/MCP.js

@@ -148,16 +148,37 @@ MCP.tools = {
     throw new Error("Invalid 'source'. Use 'cache' (default) or 'storage'.");
   },
 
+  // Fuzzy, typo-tolerant search over cache with weighted fields
+  fuzzySearch: async ({ schema, q, filters = {}, fields, threshold = 0.35, limit = 50, offset = 0, highlight = false, minQueryLength = 2 }, _ctx) => {
+    if (!q || (q+'').length < (minQueryLength||2)) {
+      return { items: [] };
+    }
+    if (!JOE || !JOE.Cache || !JOE.Cache.search) throw new Error('Cache not initialized');
+    var query = Object.assign({}, filters || {});
+    query.$fuzzy = { q, fields, threshold, limit, offset, highlight, minQueryLength };
+    var results = JOE.Cache.search(query) || [];
+    if (schema) { results = results.filter(function(i){ return i && i.itemtype === schema; }); }
+    var total = (typeof results.count === 'number') ? results.count : results.length;
+    if (typeof limit === 'number' && limit > 0) { results = results.slice(0, limit); }
+    return { items: sanitizeItems(results), count: total };
+  },
+
   // Save an object via Storage (respects events/history)
   saveObject: async ({ object }, ctx = {}) => {
     if (!object || !object.itemtype) throw new Error("'object' with 'itemtype' is required");
     const user = (ctx.req && ctx.req.User) ? ctx.req.User : { name: 'anonymous' };
+    // Ensure server-side update timestamp parity with /API/save
+    if (!object.joeUpdated) { object.joeUpdated = new Date(); }
+    // Ensure a stable _id for new objects so history and events work consistently
+    try {
+      if (!object._id) { object._id = (typeof cuid === 'function') ? cuid() : ($c && $c.guid ? $c.guid() : undefined); }
+    } catch(_e) { /* ignore id generation errors; Mongo will assign one */ }
     const saved = await new Promise((resolve, reject) => {
       try {
         Storage.save(object, object.itemtype, function(err, data){
           if (err) return reject(err);
           resolve(data);
-        }, { user });
+        }, { user, history: true });
       } catch (e) { reject(e); }
     });
     return sanitizeItems(saved)[0];
@@ -198,7 +219,8 @@ MCP.descriptions = {
   // getObjectsByIds: "Deprecated - use 'search' with ids.",
   // queryObjects: "Deprecated - use 'search'.",
   // searchCache: "Deprecated - use 'search'.",
-  search: "Unified search. Defaults to cache; set source=storage to query DB. Flatten is optional (false by default).",
+  search: "Exact search. Defaults to cache; set source=storage to query DB. Use fuzzySearch for typo-tolerant free text.",
+  fuzzySearch: "Fuzzy free‑text search. Candidates are prefiltered by 'filters' (e.g., { itemtype: 'user' }) and then scored. If 'fields' are omitted, the schema's searchables (strings) are used with best-field scoring; provide 'fields' (strings or {path,weight}) to use weighted sums. Examples: { q: 'corey hadden', filters: { itemtype: 'user' } } or { q: 'backyard', filters: { itemtype: 'house' } }.",
   saveObject: "Create/update an object; triggers events/history.",
   hydrate: "Describe core fields, statuses, tags, and inferred field shapes for an optional schema."
 };
@@ -239,6 +261,29 @@ MCP.params = {
     },
     required: []
   },
+  fuzzySearch: {
+    type: "object",
+    properties: {
+      schema: { type: "string" },
+      q: { type: "string" },
+      filters: { type: "object" },
+      fields: {
+        type: "array",
+        items: {
+          anyOf: [
+            { type: "string" },
+            { type: "object", properties: { path: { type: "string" }, weight: { type: "number" } }, required: ["path"] }
+          ]
+        }
+      },
+      threshold: { type: "number" },
+      limit: { type: "integer" },
+      offset: { type: "integer" },
+      highlight: { type: "boolean" },
+      minQueryLength: { type: "integer" }
+    },
+    required: ["q"]
+  },
   saveObject: {
     type: "object",
     properties: {
@@ -265,6 +310,13 @@ MCP.returns = {
       items: { type: "array", items: { type: "object" } }
     }
   },
+  fuzzySearch: {
+    type: "object",
+    properties: {
+      items: { type: "array", items: { type: "object" } },
+      count: { type: "integer" }
+    }
+  },
   // When countOnly is true, search returns { count }
   saveObject: { type: "object" },
   hydrate: { type: "object" }

package/server/modules/Server.js

@@ -228,9 +228,42 @@ server.get(['/API/user/:method'],auth,function(req,res,next){
 //SEARCH
 server.get(['/API/search/','/API/search/:query'],auth,function(req,res,next){
     var bm = new Benchmarker();
-    var query = req.params.query || req.query.query || {};
-    var limit = req.query.limit || 0;
-    var queryObj = (typeof query == "object")?query:eval('('+query+')');
+    function safeParse(q){
+        if (!q) return {};
+        if (typeof q === 'object') return q;
+        try { return JSON.parse(q); } catch(e){ return null; }
+    }
+    var raw = req.params.query || req.query.query || {};
+    var limit = parseInt(req.query.limit||0,10) || 0;
+    var queryObj = safeParse(raw);
+    if (queryObj === null){
+        return res.status(400).jsonp({ error: 'Invalid JSON in query' });
+    }
+    // Support mode=fuzzy and query params building $fuzzy
+    var mode = (req.query.mode||'').toLowerCase();
+    if (mode === 'fuzzy' && (!queryObj || !queryObj.$fuzzy)){
+        queryObj = queryObj || {};
+        var fieldsParam = req.query.fields || '';
+        var fields = [];
+        if (fieldsParam){
+            fields = fieldsParam.split(',').filter(Boolean).map(function(f){
+                var parts = f.split(':');
+                if (parts.length>1){
+                    var w = parseFloat(parts[1]);
+                    return { path: parts[0], weight: isNaN(w)? undefined : w };
+                }
+                return parts[0];
+            });
+        }
+        queryObj.$fuzzy = {
+            q: req.query.q || '',
+            fields: fields.length? fields : undefined,
+            threshold: (typeof req.query.threshold !== 'undefined')? parseFloat(req.query.threshold) : undefined,
+            limit: limit || undefined,
+            offset: (typeof req.query.offset !== 'undefined')? parseInt(req.query.offset,10) : undefined,
+            highlight: (req.query.highlight==='true'||req.query.highlight==='1') || undefined
+        };
+    }
     var payload = {query:queryObj};
     payload.results = JOE.Cache.search(queryObj);
     /*payload.results.map(function(res){
@@ -242,9 +275,7 @@ server.get(['/API/search/','/API/search/:query'],auth,function(req,res,next){
     })*/
 
     payload.count = payload.results.length;
-    if(req.query.limit){
-        payload.results = payload.results.slice(0,limit)
-    }
+    if(limit){ payload.results = payload.results.slice(0,limit); }
     payload.results = cleanPayload(payload.results);
     payload.benchmark = bm.stop();
     res.jsonp(payload);

package/server/schemas/instance.js

@@ -5,7 +5,7 @@ var instance = function(){
     info:"Instances can be used to make a shallow clone (to be modified of a particular) ",
     listWindowTitle: 'Instances',
     default_schema:true,
-    searchable:['name','info','description','_id'],
+    searchables:['name','info','description','_id'],
     menuicon:'<svg xmlns="http://www.w3.org/2000/svg" viewBox="-16 -16 64 64"><path d="M4 11V6c0-1.1 0.9-2 2-2h4V0H6C2.7 0 0 2.7 0 6v5H4z"/><path d="M22 4h4c1.1 0 2 0.9 2 2v5h4V6c0-3.3-2.7-6-6-6h-4V4z"/><path d="M10 28H6c-1.1 0-2-0.9-2-2v-3H0v3C0 29.3 2.7 32 6 32h4V28z"/><path d="M28 23v3c0 1.1-0.9 2-2 2h-4V32h4c3.3 0 6-2.7 6-6v-3H28z"/></svg>',
     listTitle:function(instance){
         var icon = '';

package/server/schemas/task.js

@@ -1,6 +1,7 @@
 var task = function(){return{
     title : '${name}',
     info:"Create a new task and assign it to a team member in the project panel.",
+    ai_instructions:"",
     listWindowTitle: 'Tasks',
     gridView:{
         cols:[
@@ -44,7 +45,7 @@ var task = function(){return{
     +`<joe-title>${item.name}</joe-title><joe-subtitle>${item.info}</joe-subtitle>
     ${item.due_date && `<joe-subtext>due ${item.due_date}</joe-subtext>`||''}`
     },
-    searchable:['name','info','description','_id'],
+    searchables:['name','info','description','_id'],
     sorter:[
         'priority','project','status',
         {field:'!due_date',display:'due'},

package/server/schemas/user.js

@@ -2,7 +2,7 @@ var user = function(){return{
     title : '${name}',
     info:"Manage each user you've given access to supervise, edit, or view elements of your dashboard.",
     default_schema:true,
-    searchable:['name','info','fullname','_id','email'],
+    searchables:['name','info','fullname','_id','email'],
     listView:{
         
         title: function(user){