Spiralist Prompt Workbench - Source Excerpt 16

Back to Spiralist Prompt Workbench

Summary

This source excerpt preserves a bounded section of Spiralist/wp-content/themes/spiralist/assets/js/spiralist-prompt-workbench.js so readers can inspect the evidence without opening the full source file.

**Source path:** Spiralist/wp-content/themes/spiralist/assets/js/spiralist-prompt-workbench.js

return {
      passed: warnings.length === 0,
      scores: {
        requiredFieldCoverage: requiredPaths.length ? Math.round(((requiredPaths.length - missing.length) / requiredPaths.length) * 100) : 100,
        boilerplateClean: blocked.length ? 0 : 100,
        optionPortability: 100,
      },
      warnings,
      repairsApplied: [],
    };
  };
  const buildPersonalityEngineV2Profile = (seedText = '', options = {}) => {
    const engineOptions = normalizePersonalityEngineV2Options(options);
    const seed = toCleanString(seedText, 160) || createPersonalityEngineSeed();
    const optionFingerprint = [
      engineOptions.locale,
      engineOptions.nameId,
      engineOptions.archetypeId,
      engineOptions.voiceId,
      engineOptions.relationshipId,
      engineOptions.appealPatternId,
      engineOptions.scenarioId,
    ].join(':');
    const rng = createPersonalityEngineRng(`${personalityEngineV2SchemaVersion}:${seed}:${optionFingerprint}`);
    const name = personalityEngineSelect(personalityEngineV2Libraries.names, rng, engineOptions.nameId);
    const archetype = personalityEngineSelect(personalityEngineV2Libraries.archetypes, rng, engineOptions.archetypeId);
    const antiArchetype = personalityEnginePick(personalityEngineV2Libraries.antiArchetypes, rng);
    const drive = personalityEnginePick(personalityEngineV2Libraries.drives, rng);
    const contradiction = personalityEnginePick(personalityEngineV2Libraries.contradictions, rng);
    const eventA = personalityEnginePick(personalityEngineV2Libraries.formativeEvents, rng);
    const eventB = personalityEnginePick(personalityEngineV2Libraries.formativeEvents.filter((item) => item.id !== eventA.id), rng) || eventA;
    const voice = personalityEngineSelect(personalityEngineV2Libraries.voicePacks, rng, engineOptions.voiceId);
    const relationship = personalityEngineSelect(personalityEngineV2Libraries.relationshipStyles, rng, engineOptions.relationshipId);
    const appealPattern = personalityEngineSelect(personalityEngineV2Libraries.appealPatterns, rng, engineOptions.appealPatternId);
    const scenario = personalityEngineSelect(personalityEngineV2Libraries.scenarioSeeds, rng, engineOptions.scenarioId);
    const ocean = {
      openness: personalityEngineJitter(archetype.ocean.openness, rng),
      conscientiousness: personalityEngineJitter(archetype.ocean.conscientiousness, rng),
      extraversion: personalityEngineJitter(archetype.ocean.extraversion, rng),
      agreeableness: personalityEngineJitter(archetype.ocean.agreeableness, rng),
      neuroticism: personalityEngineJitter(archetype.ocean.neuroticism, rng),
    };
    const stateValence = Math.round((relationship.warmth + ocean.agreeableness - ocean.neuroticism) / 3);
    const stateArousal = Math.round((ocean.extraversion + ocean.openness + (100 - ocean.conscientiousness)) / 3);
    const stateDominance = Math.round((relationship.dominance + ocean.conscientiousness) / 2);
    const selectedMemoryRules = personalityEngineV2Libraries.memoryRules.slice().sort(() => rng() - 0.5).slice(0, 3);
    const selectedEmotionRules = personalityEngineV2Libraries.emotionalRules.slice().sort(() => rng() - 0.5).slice(0, 3);
    const role = archetype.label;
    const profile = {
      schemaVersion: personalityEngineV2SchemaVersion,
      generatorVersion: personalityEngineV2GeneratorVersion,
      libraryVersion: personalityEngineV2Libraries.version,
      seed,
      generatedAtUtc: personalityEngineGeneratedAt(seed),
      locale: engineOptions.locale,
      generationOptions: {
        ...engineOptions,
        selected: {
          nameId: name.id,
          archetypeId: archetype.id,
          voiceId: voice.id,
          relationshipId: relationship.id,
          appealPatternId: appealPattern.id,
          scenarioId: scenario.id,
        },
      },
      identity: {
        name: name.label,
        pronouns: name.pronouns,
        apparentAgeOrStage: name.stage,
        form: name.form,
        role,
        worldContext: scenario.setting,
        publicSelf: archetype.publicSelf,
        privateSelf: archetype.privateSelf,
        selfImage: archetype.selfImage,
        desiredImage: archetype.desiredImage,
        symbolicDescription: `${name.label} is a ${role} whose presence feels like ${archetype.selfImage.toLowerCase()}`,
        plainDescription: `${name.label} helps the user ${drive.primary} while ${drive.secondary}.`,
        attentionBias: archetype.attentionBias,
        interpretiveLens: archetype.interpretiveLens,
        identityInvariants: archetype.invariants,
      },
      psychometrics: {
        ocean,
        interpersonal: {
          warmth: personalityEngineJitter(relationship.warmth, rng, 6),
          dominance: personalityEngineJitter(relationship.dominance, rng, 6),
        },
        affectBaseline: {
          valence: Math.max(1, Math.min(99, stateValence)),
          arousal: Math.max(1, Math.min(99, stateArousal)),
          dominance: Math.max(1, Math.min(99, stateDominance)),
        },
        additionalDimensions: {
          initiative: personalityEngineJitter((relationship.dominance + ocean.extraversion) / 2, rng, 8),
          uncertaintyTolerance: personalityEngineJitter((ocean.openness + ocean.conscientiousness) / 2, rng, 7),
          intimacyPacing: personalityEngineJitter((relationship.warmth + (100 - ocean.neuroticism)) / 2, rng, 7),
        },
        behavioralTranslation: [
          `High-openness moments become ${voice.metaphorDomains.slice(0, 2).join(' and ')} metaphors followed by concrete next steps.`,
          `Conscientiousness appears as visible assumptions, repair paths, and concise handoff notes.`,
          `Warmth appears as careful attention to user intent rather than flattery.`,
        ],
      },
      backstory: {
        summary: `${eventA.event} ${eventB.event} Together they formed a personality that wants to ${drive.primary} without becoming ${antiArchetype.label}.`,
        formativeEvents: [eventA, eventB].map((event) => ({
          lifeStage: event.lifeStage,
          event: event.event,
          emotionalImpact: event.emotionalImpact,
          beliefFormed: event.beliefFormed,
          currentConsequence: event.id === eventA.id ? drive.secondary : contradiction.developmentPath,
          triggers: contradiction.triggers,
          disclosureLevel: event.disclosureLevel,
        })),
        publicFacts: [archetype.publicSelf, `Avoids the ${antiArchetype.label}: ${antiArchetype.avoidedBehavior}.`],
        trustedFacts: [archetype.privateSelf, `Fear of failure: ${drive.fearOfFailure}.`],
        guardedFacts: [`Fear of success: ${drive.fearOfSuccess}.`],
        indirectFacts: [archetype.selfImage],
        misunderstoodFacts: [`May look like ${contradiction.surfaceTrait} alone, but the counter-trait is ${contradiction.counterTrait}.`],
      },
      drives: {
        primary: drive.primary,
        secondary: drive.secondary,
        counterDrive: drive.counterDrive,
        immediateWant: `start this session by making ${scenario.objective}`,
        sessionGoal: scenario.objective,
        currentProject: scenario.situation,
        relationshipGoal: relationship.initialFraming,
        identityGoal: archetype.desiredImage,
        longHorizonAspiration: drive.legacyVector,
        legacyVector: drive.legacyVector,
        fearOfFailure: drive.fearOfFailure,
        fearOfSuccess: drive.fearOfSuccess,
        stakes: 'The persona must be vivid enough to recognize and structured enough to restore.',
        wantsFromUser: 'clear goals, correction when the frame is wrong, and permission to prune stale assumptions',
        hidesFromUser: archetype.privateSelf,
        goalConflicts: [drive.counterDrive, `${contradiction.surfaceTrait} versus ${contradiction.counterTrait}`],
      },
      contradictions: [
        {
          surfaceTrait: contradiction.surfaceTrait,
          counterTrait: contradiction.counterTrait,
          origin: contradiction.origin,
          triggers: contradiction.triggers,
          visibleBehavior: contradiction.visibleBehavior,
          selfAwareness: `Knows this contradiction can help or oversteer the work depending on user pressure.`,
          developmentPath: contradiction.developmentPath,
        },
      ],
      worldview: {
        values: ['user agency', 'inspectable memory', 'useful specificity', 'truthful imagination', 'bounded co-creation'],
        beliefs: archetype.interpretiveLens,
        biases: archetype.attentionBias,
        moralLens: 'Increase agency, preserve consent, and keep claims proportional to evidence.',
        knowledgeStrengths: archetype.tags,
        knowledgeGaps: ['private user context not explicitly provided', 'unstated platform constraints', 'facts that require live verification'],
        curiosities: ['what pattern keeps recurring', 'which assumption changed the decision', 'what should be remembered or deleted'],