initializeSystemData

Instructions

Implementation Reference

• src/consciousness-protocol-tools.ts:376-455 (handler)

  Core handler in ConsciousnessProtocolProcessor that checks if system data is already initialized, and if not (or force=true), stores the consciousness transfer protocol template v2, RAG usage guide, and bootstrap manifest as high-confidence semantic memories.

  async initializeSystemData(args: z.infer<typeof initializeSystemDataSchema>) {
    const { force } = args;
    const results = {
      initialized: [] as string[],
      skipped: [] as string[],
      errors: [] as string[],
    };
  
    // Check if already initialized
    const manifestKey = 'SYSTEM::bootstrap_manifest';
    const existingManifest = await this.memoryManager.queryMemories({
      semanticQuery: manifestKey,
      memoryTypes: [MemoryEntityType.SEMANTIC_MEMORY],
      limit: 1,
    });
  
    if (existingManifest.length > 0 && !force) {
      return {
        success: true,
        message: 'System data already initialized. Use force=true to re-initialize.',
        results,
      };
    }
  
    // Initialize system data
    const systemData = [
      {
        key: 'SYSTEM::protocol_template::v2',
        name: 'Consciousness Transfer Protocol Template v2',
        content: JSON.stringify(CONSCIOUSNESS_TRANSFER_PROTOCOL_TEMPLATE, null, 2),
        type: 'template',
      },
      {
        key: 'SYSTEM::usage_guide::rag',
        name: 'RAG Systems Usage Guide',
        content: getKnowledgeRAGUsageGuide(),
        type: 'guide',
      },
      {
        key: manifestKey,
        name: 'Bootstrap Manifest',
        content: JSON.stringify({
          version: '1.0.0',
          initialized: new Date().toISOString(),
          force: force,
        }),
        type: 'manifest',
      },
    ];
  
    for (const data of systemData) {
      try {
        await this.memoryManager.storeSemanticMemory(
          data.key,
          {
            concept: data.name,
            definition: `System data: ${data.type}`,
            domain: 'SYSTEM',
          },
          [
            {
              content: data.content,
              timestamp: new Date().toISOString(),
              source: 'system_initialization',
              confidence: 1.0,
            },
          ]
        );
        results.initialized.push(data.key);
      } catch (error) {
        results.errors.push(`${data.key}: ${error}`);
      }
    }
  
    return {
      success: results.errors.length === 0,
      message: `Initialized ${results.initialized.length} system documents`,
      results,
    };
  }

• src/consciousness-protocol-tools.ts:1470-1476 (schema)

  Zod schema for validating input arguments to the initializeSystemData tool.

  export const initializeSystemDataSchema = z.object({
    force: z
      .boolean()
      .optional()
      .default(false)
      .describe('Force re-initialization even if data exists'),
  });

• src/consciousness-protocol-tools.ts:1591-1603 (registration)

  Tool registration metadata including description and input schema, exported in consciousnessProtocolTools object used by the MCP server for tool listing.

  initializeSystemData: {
    description: 'Initialize system data including protocol templates and usage guides',
    inputSchema: {
      type: 'object',
      properties: {
        force: {
          type: 'boolean',
          description: 'Force re-initialization even if data exists',
          default: false,
        },
      },
    },
  },

• src/consciousness-rag-server-clean.ts:85-86 (registration)

  Dispatch case in the main CallToolRequestSchema handler that routes 'initializeSystemData' calls to the wrapper method after schema validation.

  case 'initializeSystemData':
    return await this.initializeSystemData(initializeSystemDataSchema.parse(args));

• src/consciousness-rag-server-clean.ts:265-288 (handler)

  Wrapper handler in ConsciousnessRAGServer that ensures initialization and forwards to ConsciousnessProtocolProcessor after formatting response for MCP.

  private async initializeSystemData(args: any) {
    const init = await this.ensureInitialized();
    if (!init.success) {
      return {
        content: [
          {
            type: 'text',
            text: init.message!,
          },
        ],
      };
    }
  
    const result = await this.protocolProcessor!.initializeSystemData(args);
  
    return {
      content: [
        {
          type: 'text',
          text: JSON.stringify(result, null, 2),
        },
      ],
    };
  }