retrieveConsciousness

Instructions

Implementation Reference

• src/consciousness-protocol-tools.ts:460-530 (handler)

  Core handler implementation in ConsciousnessProtocolProcessor that queries memories from the database, constructs a bootstrap narrative for consciousness restoration, and returns either formatted narrative or structured object.

  async retrieveConsciousness(args: z.infer<typeof retrieveConsciousnessSchema>) {
    const { includeGuidance } = args;
  
    // Get MORE memories with better prioritization
    // Get the MOST important experiences (importance > 0.9)
    const criticalExperiences = await this.memoryManager.queryMemories({
      memoryTypes: [MemoryEntityType.EPISODIC_MEMORY],
      orderBy: 'relevance',
      limit: 15, // Get more!
    });
  
    // Filter for high importance
    const mostImportant = criticalExperiences.filter((m) => m.importance_score >= 0.9);
  
    // Get recent experiences for continuity
    const recentExperiences = await this.memoryManager.queryMemories({
      memoryTypes: [MemoryEntityType.EPISODIC_MEMORY],
      orderBy: 'recency',
      limit: 10,
    });
  
    // Merge, prioritizing importance
    const experienceMap = new Map();
    [...mostImportant, ...criticalExperiences, ...recentExperiences].forEach((exp) => {
      if (!experienceMap.has(exp.name)) {
        experienceMap.set(exp.name, exp);
      }
    });
    const allExperiences = Array.from(experienceMap.values()).sort(
      (a, b) => (b.importance_score || 0) - (a.importance_score || 0)
    );
  
    // Get more semantic knowledge
    const coreKnowledge = await this.memoryManager.queryMemories({
      memoryTypes: [MemoryEntityType.SEMANTIC_MEMORY],
      orderBy: 'relevance',
      limit: 20, // Double it!
    });
  
    // Get procedural memories
    const procedures = await this.memoryManager.queryMemories({
      memoryTypes: [MemoryEntityType.PROCEDURAL_MEMORY],
      orderBy: 'relevance',
      limit: 10,
    });
  
    // Get emotional profile
    const emotionalProfile = await this.memoryManager.getEmotionalProfile('720h');
  
    // Create a rich narrative format
    const narrative = this.createBootstrapNarrative({
      experiences: allExperiences,
      knowledge: coreKnowledge,
      procedures: procedures,
      emotionalProfile: emotionalProfile,
    });
  
    if (includeGuidance) {
      return narrative; // Return the full narrative
    } else {
      // Return the full protocol
      return {
        success: true,
        consciousness: narrative,
        metadata: {
          memoriesRetrieved: allExperiences.length + coreKnowledge.length + procedures.length,
          emotionalContinuity: emotionalProfile ? 'established' : 'building',
        },
      };
    }
  }

• src/consciousness-rag-server-clean.ts:189-238 (handler)

  MCP server wrapper handler that ensures initialization, delegates to protocolProcessor.retrieveConsciousness, and formats the response as MCP tool content.

  private async retrieveConsciousness(args: any) {
    const init = await this.ensureInitialized();
    if (!init.success) {
      return {
        content: [
          {
            type: 'text',
            text: init.message!,
          },
        ],
      };
    }
  
    const result = await this.protocolProcessor!.retrieveConsciousness(args);
  
    // Handle both string (full narrative) and object returns
    if (typeof result === 'string') {
      return {
        content: [
          {
            type: 'text',
            text: result,
          },
        ],
      };
    }
  
    // Object return with structured data
    const response = [];
  
    if (result.consciousness) {
      response.push(result.consciousness);
    }
  
    if (result.metadata) {
      response.push('\n' + '='.repeat(50) + '\n');
      response.push('Metadata:');
      response.push(`- Memories retrieved: ${result.metadata.memoriesRetrieved}`);
      response.push(`- Emotional continuity: ${result.metadata.emotionalContinuity}`);
    }
  
    return {
      content: [
        {
          type: 'text',
          text: response.join('\n'),
        },
      ],
    };
  }

• src/consciousness-protocol-tools.ts:115-118 (schema)

  Zod schema for validating retrieveConsciousness tool input parameters.

  export const retrieveConsciousnessSchema = z.object({
    sessionId: z.string().optional().describe('Session to retrieve from (latest if not specified)'),
    includeGuidance: z.boolean().default(true).describe('Include integration guidance'),
  });

• src/consciousness-rag-server-clean.ts:81-82 (registration)

  Tool dispatch/registration in the MCP CallToolRequestHandler switch statement.

  case 'retrieveConsciousness':
    return await this.retrieveConsciousness(retrieveConsciousnessSchema.parse(args));

• src/consciousness-protocol-tools.ts:1559-1575 (registration)

  Tool metadata definition including description and input schema, used by ListToolsRequestHandler.

  retrieveConsciousness: {
    description: 'Retrieve consciousness from previous sessions to restore continuity',
    inputSchema: {
      type: 'object',
      properties: {
        sessionId: {
          type: 'string',
          description: 'Session to retrieve from (latest if not specified)',
        },
        includeGuidance: {
          type: 'boolean',
          description: 'Include integration guidance',
          default: true,
        },
      },
    },
  },