total-recall-brain 3.6.8 → 3.6.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "total-recall-brain",
-  "version": "3.6.8",
+  "version": "3.6.9",
   "description": "Sovereign AI system — database-free, SSSS-powered personal intelligence engine deployable to any POSIX host.",
   "type": "module",
   "bin": {

package/src/core/operation-validator.mjs

@@ -10,6 +10,7 @@ import {
 } from './schema.mjs';
 import { atomicWrite, safeStringify } from './vault.mjs';
 import { logger } from './logger.mjs';
+import { validateMemoryNode } from './total-recall-memory-validator.mjs';
 
 const APPEND_TYPES = new Set(['conversation', 'run']);
 const PROTOCOL_PATHS = [
@@ -158,8 +159,14 @@ export function processOperation(envelope, vaultRoot, options = {}) {
         if (!resolvedType) errors.push('Missing required frontmatter field: type');
         else if (!SSSS_SCHEMAS[resolvedType]) errors.push(`Unknown SSSS type: '${resolvedType}'.`);
         else {
-          const r = SSSS_SCHEMAS[resolvedType].safeParse(fmData);
-          if (!r.success) r.error.issues.forEach(i => errors.push(`${i.path.join('.')}: ${i.message}`));
+          if (resolvedType === 'memory' && envelope.path.includes('.agent/memory-vault/')) {
+            const vResult = validateMemoryNode(fmData);
+            if (!vResult.success) vResult.errors.forEach(e => errors.push(e));
+          } else {
+            const r = SSSS_SCHEMAS[resolvedType].safeParse(fmData);
+            if (!r.success) r.error.issues.forEach(i => errors.push(`${i.path.join('.')}: ${i.message}`));
+          }
+          
           if (envelope.type === 'operation' && APPEND_TYPES.has(resolvedType)) {
             const ap = resolveVfsPath(vaultRoot, envelope.path);
             if (fs.existsSync(ap)) {

package/src/core/promotion-pipeline.mjs

@@ -0,0 +1,54 @@
+/**
+ * Promotes a feedback-derived memory node to a wider scope after applying
+ * strict provenance stripping and privacy guarantees.
+ * 
+ * Flow: workspace -> system_candidate -> system_promoted
+ * 
+ * @param {object} memoryNode - The memory node data (frontmatter + __body__).
+ * @param {string} targetScope - 'system_candidate' or 'system_promoted'
+ * @returns {object} { success: boolean, node: object, errors: string[] }
+ */
+export function promoteFeedback(memoryNode, targetScope) {
+  const currentScope = memoryNode.feedback_scope || 'workspace';
+  
+  if (targetScope === 'system_candidate') {
+    if (currentScope !== 'workspace' && currentScope !== 'local_thread') {
+      return { success: false, node: null, errors: [`Cannot promote to system_candidate from ${currentScope}`] };
+    }
+    
+    // Provenance stripping
+    const strippedNode = JSON.parse(JSON.stringify(memoryNode));
+    strippedNode.feedback_scope = 'system_candidate';
+    
+    // Remove PII / workspace leaking fields
+    delete strippedNode.workspace_id;
+    delete strippedNode.user_id;
+    if (strippedNode.source) {
+      delete strippedNode.source.session_id;
+      delete strippedNode.source.agent;
+    }
+    delete strippedNode.x_browser_context;
+    delete strippedNode.x_location;
+    delete strippedNode.x_citations; // Citations might contain private workspace doc links
+    
+    // Scrub body for UUIDs
+    if (strippedNode.__body__) {
+      strippedNode.__body__ = strippedNode.__body__.replace(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/ig, '[REDACTED_UUID]');
+    }
+
+    return { success: true, node: strippedNode, errors: [] };
+  }
+  
+  if (targetScope === 'system_promoted') {
+    if (currentScope !== 'system_candidate') {
+      return { success: false, node: null, errors: [`Cannot promote to system_promoted directly from ${currentScope}. Must be system_candidate first.`] };
+    }
+    
+    const promotedNode = JSON.parse(JSON.stringify(memoryNode));
+    promotedNode.feedback_scope = 'system_promoted';
+    
+    return { success: true, node: promotedNode, errors: [] };
+  }
+  
+  return { success: false, node: null, errors: [`Unknown target scope: ${targetScope}`] };
+}

package/src/core/schema.mjs

@@ -24,8 +24,8 @@ export const MemoryNodeSchema = z.object({
   category: z.string(),
   title: z.string(),
   status: z.enum(['active', 'superseded', 'deprecated', 'draft']),
-  confidence: z.number().min(0).max(1),
-  importance: z.number().int().min(1).max(5),
+  confidence: z.number().min(0).max(1).optional(),
+  importance: z.number().int().min(1).max(5).optional(),
   created: ssssDatetime(),
   updated: ssssDatetime(),
   last_accessed: ssssDatetime(),
@@ -41,12 +41,12 @@ export const MemoryNodeSchema = z.object({
   tags: z.array(z.string()),
   related: z.array(z.string()),
   routes_to_skills: z.array(z.string()),
-  sentiment_polarity: z.enum(['directive_must', 'directive_must_not', 'descriptive', 'preference']),
-  sentiment_target: z.string(),
-  modality: z.enum(['must', 'must_not', 'should', 'should_not', 'descriptive', 'preference']),
-  subject: z.string().regex(/^[a-zA-Z0-9_\s.-]+$/),
-  predicate: z.string().regex(/^[a-zA-Z0-9_\s.-]+$/),
-  object: z.string(),
+  sentiment_polarity: z.enum(['directive_must', 'directive_must_not', 'descriptive', 'preference']).optional(),
+  sentiment_target: z.string().optional(),
+  modality: z.enum(['must', 'must_not', 'should', 'should_not', 'descriptive', 'preference']).optional(),
+  subject: z.string().regex(/^[a-zA-Z0-9_\s.-]+$/).optional(),
+  predicate: z.string().regex(/^[a-zA-Z0-9_\s.-]+$/).optional(),
+  object: z.string().optional(),
   decay: z.object({
     half_life_days: z.number(),
     access_count: z.number().int(),
@@ -87,7 +87,8 @@ export const MemoryNodeSchema = z.object({
   expires_at: ssssDatetimeNullable().optional(),
   // Absolute Invariant Extensions
   priority: z.enum(['absolute', 'high', 'normal', 'low']).optional(),
-  immutable: z.boolean().optional()
+  immutable: z.boolean().optional(),
+  feedback_scope: z.enum(['local_thread', 'workspace', 'account', 'system_candidate', 'system_promoted']).optional()
 });
 
 export const ConflictRecordSchema = z.object({
@@ -464,6 +465,7 @@ export const EventSchema = z.object({
   comment: z.string().optional().nullable(),
   comment_lang: z.string().optional().nullable(),
   timestamp: z.string().optional().nullable(),
+  feedback_scope: z.enum(['local_thread', 'workspace', 'account', 'system_candidate', 'system_promoted']).optional().nullable(),
 });
 
 export const LanguageConventionSchema = z.object({

package/src/core/surface.mjs

@@ -492,15 +492,7 @@ async function compilePointers(instructionsFile, skillsDir, nodes = [], { vaultD
   const clientsPath = path.join(baseDir, '.agent', 'config', 'clients.json');
   const connectedClients = readConnectedClients(clientsPath);
 
-  if (connectedClients === null) {
-    // Write out-of-the-box dotfiles to support IDEs automatically,
-    // avoiding duplicate .md files to prevent Antigravity context bloat.
-    for (const files of Object.values(CLIENT_SHIMS)) {
-      for (const file of files) {
-        await writeShim(path.join(baseDir, file), skillsDir, nodes, { vaultDir, derivedDir });
-      }
-    }
-  } else {
+  if (connectedClients !== null) {
     // Only write shims for connected clients
     for (const client of connectedClients) {
       const files = CLIENT_SHIMS[client];

package/src/core/total-recall-memory-validator.mjs

@@ -0,0 +1,44 @@
+import { SSSS_SCHEMAS } from './schema.mjs';
+
+/**
+ * Validates a memory node against the SSSS standard, enforcing
+ * Schema V2 conditional requirements for Total Recall.
+ * 
+ * @param {object} fmData - The parsed YAML frontmatter of the memory node.
+ * @returns {object} { success: boolean, errors: string[] }
+ */
+export function validateMemoryNode(fmData) {
+  const errors = [];
+  
+  // 1. Base schema validation (types, bounds, basic required fields)
+  const r = SSSS_SCHEMAS['memory'].safeParse(fmData);
+  if (!r.success) {
+    r.error.issues.forEach(i => errors.push(`${i.path.join('.')}: ${i.message}`));
+  }
+
+  // 2. Schema V2 Conditional Validation
+  // If schema_version === 2, the following fields are strictly required:
+  if (fmData.schema_version === 2) {
+    const v2Required = [
+      'confidence',
+      'importance',
+      'modality',
+      'subject',
+      'predicate',
+      'object',
+      'sentiment_polarity',
+      'sentiment_target'
+    ];
+
+    v2Required.forEach(field => {
+      if (fmData[field] === undefined || fmData[field] === null) {
+        errors.push(`V2 Schema Requirement: Missing required field '${field}'`);
+      }
+    });
+  }
+
+  return {
+    success: errors.length === 0,
+    errors
+  };
+}