Get Self-Dialectical AI Methodology

Instructions

Implementation Reference

• src/tools/methodology.ts:11-66 (registration)

  Registration of the 'get_methodology' tool on the MCP server with input/output schemas and handler.

  export function registerMethodologyTools(server: McpServer): void {
    // Tool: Get Self-Dialectical AI Methodology definition
    server.registerTool(
      "get_methodology",
      {
        title: "Get Self-Dialectical AI Methodology",
        description:
          "Retrieve the canonical Self-Dialectical AI Systems methodology with HUMMBL Base120 mappings.",
        inputSchema: z.object({}),
        outputSchema: z.object({
          id: z.string(),
          title: z.string(),
          version: z.string(),
          summary: z.string(),
          documentUrl: z.string().optional(),
          totalPages: z.number().optional(),
          modelsReferenced: z.array(z.string()),
          stages: z.array(
            z.object({
              stage: z.enum(["thesis", "antithesis", "synthesis", "convergence", "meta_reflection"]),
              title: z.string(),
              description: z.string(),
              modelCodes: z.array(z.string()),
            })
          ),
          metaModels: z.array(z.string()),
        }),
      },
      async () => {
        const result = getSelfDialecticalMethodology();
  
        if (!isOk(result)) {
          return {
            content: [
              {
                type: "text" as const,
                text: `Unable to retrieve Self-Dialectical methodology: ${result.error.type}`,
              },
            ],
            isError: true as const,
          };
        }
  
        const methodology = result.value;
  
        return {
          content: [
            {
              type: "text" as const,
              text: JSON.stringify(methodology, null, 2),
            },
          ],
          structuredContent: methodology as unknown as { [key: string]: unknown },
        };
      }
    );

• src/framework/self_dialectical.ts:82-84 (handler)

  Core handler: getSelfDialecticalMethodology() returns the DialecticalMethodology constant.

  export function getSelfDialecticalMethodology(): Result<DialecticalMethodology, DomainError> {
    return ok(SELF_DIALECTICAL_METHODOLOGY);
  }

• src/framework/self_dialectical.ts:16-80 (schema)

  The actual methodology data (SELF_DIALECTICAL_METHODOLOGY) including id, version, stages, models.

  export const SELF_DIALECTICAL_METHODOLOGY: DialecticalMethodology = {
    id: METHODOLOGY_ID,
    title: "Self-Dialectical AI Systems: A HUMMBL-Informed Methodology for Ethical Self-Correction",
    version: METHODOLOGY_VERSION,
    summary:
      "Enables AI systems to perform ethical self-correction through structured dialectical reasoning integrated with HUMMBL Base120 mental models.",
    documentUrl: undefined,
    totalPages: 60,
    modelsReferenced: [
      "P1",
      "P2",
      "DE3",
      "IN11",
      "IN2",
      "IN10",
      "CO4",
      "CO1",
      "CO20",
      "RE11",
      "RE15",
      "RE1",
      "RE7",
      "RE3",
      "RE16",
      "SY19",
      "SY1",
    ],
    stages: [
      {
        stage: "thesis",
        title: "Stage 1: Thesis Generation",
        description: "Generate and structure the initial ethical position.",
        modelCodes: ["P1", "P2", "DE3"],
      },
      {
        stage: "antithesis",
        title: "Stage 2: Antithesis Development",
        description:
          "Critique thesis via adversarial reasoning, premortem analysis, and red teaming.",
        modelCodes: ["IN11", "IN2", "IN10"],
      },
      {
        stage: "synthesis",
        title: "Stage 3: Synthesis Formation",
        description:
          "Integrate thesis and antithesis into a higher-order resolution across perspectives.",
        modelCodes: ["CO4", "CO1", "CO20"],
      },
      {
        stage: "convergence",
        title: "Stage 4: Convergence Testing",
        description:
          "Test and refine synthesis via calibration loops, convergence/divergence, and recursive improvement.",
        modelCodes: ["RE11", "RE15", "RE1"],
      },
      {
        stage: "meta_reflection",
        title: "Stage 5: Meta-Reflection",
        description:
          "Reflect on and improve the reasoning process itself via self-referential logic and meta-learning.",
        modelCodes: ["RE7", "RE3", "RE16"],
      },
    ],
    metaModels: ["SY19", "SY1"],
  };

• src/types/domain.ts:72-82 (schema)

  Type definition for DialecticalMethodology used as the output schema.

  export interface DialecticalMethodology {
    id: string;
    title: string;
    version: string;
    summary: string;
    documentUrl?: string;
    totalPages?: number;
    modelsReferenced: string[];
    stages: StageModelMapping[];
    metaModels: string[];
  }

• src/types/domain.ts:58-70 (schema)

  DialecticalStageId and StageModelMapping types supporting the methodology schema.

  export type DialecticalStageId =
    | "thesis"
    | "antithesis"
    | "synthesis"
    | "convergence"
    | "meta_reflection";
  
  export interface StageModelMapping {
    stage: DialecticalStageId;
    title: string;
    description: string;
    modelCodes: string[];
  }