openpersona 0.5.0 → 0.7.0

package/README.md

@@ -345,7 +345,7 @@ schemas/                # Four-layer schema definitions
 templates/              # Mustache rendering templates
 bin/                    # CLI entry point
 lib/                    # Core logic modules
-tests/                  # Tests (45 passing)
+tests/                  # Tests (60 passing)
 ```
 
 ## Development

package/bin/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 /**
  * OpenPersona CLI - Full persona package manager
- * Commands: create | install | search | uninstall | update | list | switch | publish | reset | contribute
+ * Commands: create | install | search | uninstall | update | list | switch | publish | reset | contribute | export | import
  */
 const path = require('path');
 const fs = require('fs-extra');
@@ -16,7 +16,7 @@ const { uninstall } = require('../lib/uninstaller');
 const publishAdapter = require('../lib/publisher');
 const { contribute } = require('../lib/contributor');
 const { switchPersona, listPersonas } = require('../lib/switcher');
-const { OP_SKILLS_DIR, printError, printSuccess, printInfo } = require('../lib/utils');
+const { OP_SKILLS_DIR, resolveSoulFile, printError, printSuccess, printInfo } = require('../lib/utils');
 
 const PKG_ROOT = path.resolve(__dirname, '..');
 const PRESETS_DIR = path.join(PKG_ROOT, 'presets');
@@ -24,7 +24,7 @@ const PRESETS_DIR = path.join(PKG_ROOT, 'presets');
 program
   .name('openpersona')
   .description('OpenPersona - Create, manage, and orchestrate agent personas')
-  .version('0.5.0');
+  .version('0.7.0');
 
 if (process.argv.length === 2) {
   process.argv.push('create');
@@ -163,7 +163,7 @@ program
       printError(`Persona not found: persona-${slug}`);
       process.exit(1);
     }
-    const personaPath = path.join(skillDir, 'persona.json');
+    const personaPath = resolveSoulFile(skillDir, 'persona.json');
     if (!fs.existsSync(personaPath)) {
       printError('persona.json not found');
       process.exit(1);
@@ -227,10 +227,10 @@ program
   .description('★Experimental: Reset soul evolution state')
   .action(async (slug) => {
     const skillDir = path.join(OP_SKILLS_DIR, `persona-${slug}`);
-    const personaPath = path.join(skillDir, 'persona.json');
-    const soulStatePath = path.join(skillDir, 'soul-state.json');
+    const personaPath = resolveSoulFile(skillDir, 'persona.json');
+    const soulStatePath = resolveSoulFile(skillDir, 'state.json');
     if (!fs.existsSync(personaPath) || !fs.existsSync(soulStatePath)) {
-      printError('Persona or soul-state.json not found');
+      printError('Persona or soul state not found');
       process.exit(1);
     }
     const persona = JSON.parse(fs.readFileSync(personaPath, 'utf-8'));
@@ -262,4 +262,64 @@ program
     }
   });
 
+program
+  .command('export <slug>')
+  .description('Export persona pack (with soul state) as a zip archive')
+  .option('-o, --output <path>', 'Output file path')
+  .action(async (slug, options) => {
+    const skillDir = path.join(OP_SKILLS_DIR, `persona-${slug}`);
+    if (!fs.existsSync(skillDir)) {
+      printError(`Persona not found: persona-${slug}`);
+      process.exit(1);
+    }
+    const AdmZip = require('adm-zip');
+    const zip = new AdmZip();
+    const addDir = (dir, zipPath) => {
+      for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const full = path.join(dir, entry.name);
+        const zp = zipPath ? `${zipPath}/${entry.name}` : entry.name;
+        if (entry.isDirectory()) addDir(full, zp);
+        else zip.addLocalFile(full, zipPath || '');
+      }
+    };
+    addDir(skillDir, '');
+    const outPath = options.output || `persona-${slug}.zip`;
+    zip.writeZip(outPath);
+    printSuccess(`Exported to ${outPath}`);
+  });
+
+program
+  .command('import <file>')
+  .description('Import persona pack from a zip archive and install')
+  .option('-o, --output <dir>', 'Extract directory', path.join(require('os').tmpdir(), 'openpersona-import-' + Date.now()))
+  .action(async (file, options) => {
+    if (!fs.existsSync(file)) {
+      printError(`File not found: ${file}`);
+      process.exit(1);
+    }
+    const AdmZip = require('adm-zip');
+    const zip = new AdmZip(file);
+    const extractDir = options.output;
+    await fs.ensureDir(extractDir);
+    zip.extractAllTo(extractDir, true);
+
+    const personaPath = resolveSoulFile(extractDir, 'persona.json');
+    if (!fs.existsSync(personaPath)) {
+      printError('Not a valid persona archive: persona.json not found');
+      await fs.remove(extractDir);
+      process.exit(1);
+    }
+
+    try {
+      const destDir = await install(extractDir);
+      printSuccess(`Imported and installed from ${file}`);
+      if (extractDir.startsWith(require('os').tmpdir())) {
+        await fs.remove(extractDir);
+      }
+    } catch (e) {
+      printError(e.message);
+      process.exit(1);
+    }
+  });
+
 program.parse();

package/lib/generator.js

@@ -91,11 +91,6 @@ function buildBackstory(persona) {
   return parts.join(' ');
 }
 
-function buildCapabilitiesSection(capabilities) {
-  if (!capabilities || capabilities.length === 0) return '';
-  return capabilities.map((c) => `- ${c}`).join('\n');
-}
-
 function collectAllowedTools(persona, faculties) {
   const set = new Set(BASE_ALLOWED_TOOLS);
   const src = Array.isArray(persona.allowedTools) ? persona.allowedTools : [];
@@ -105,8 +100,22 @@ function collectAllowedTools(persona, faculties) {
 }
 
 function readFacultySkillMd(faculty, persona) {
-  const raw = fs.readFileSync(path.join(faculty._dir, 'SKILL.md'), 'utf-8');
-  // Render Mustache variables (e.g. {{slug}}) inside faculty SKILL.md
+  let raw = fs.readFileSync(path.join(faculty._dir, 'SKILL.md'), 'utf-8');
+
+  // Strip <details>...</details> blocks (operator reference, not needed by agent)
+  raw = raw.replace(/<details>[\s\S]*?<\/details>\s*/g, '');
+
+  // Strip reference-only sections that don't help the agent in conversation
+  const refSections = ['Environment Variables', 'Error Handling'];
+  for (const heading of refSections) {
+    const pattern = new RegExp(
+      `^## ${heading}\\b[\\s\\S]*?(?=^## |$(?!\\n))`,
+      'gm'
+    );
+    raw = raw.replace(pattern, '');
+  }
+
+  raw = raw.replace(/\n{3,}/g, '\n\n').trim();
   return Mustache.render(raw, persona);
 }
 
@@ -226,18 +235,24 @@ async function generate(personaPathOrObj, outputDir, options = {}) {
     persona.facultyConfigs = facultyConfigs;
   }
 
+  // Body layer — detect soft-ref (declared with install but not locally available)
+  const rawBody = persona.body || persona.embodiments?.[0] || null;
+  const softRefBody = rawBody && typeof rawBody === 'object' && rawBody.install
+    ? { name: rawBody.name || 'body', install: rawBody.install }
+    : null;
+
   const faculties = facultyNames;
   // Load faculties — external ones (with install) may not exist locally yet
   const loadedFaculties = [];
+  const softRefFaculties = [];
   for (let i = 0; i < faculties.length; i++) {
     const name = faculties[i];
     const entry = rawFaculties[i];
     if (entry.install) {
-      // External faculty — try local first, skip if not found yet
       try {
         loadedFaculties.push(loadFaculty(name));
       } catch {
-        // Will be available after installation — skipped for now
+        softRefFaculties.push({ name, install: entry.install });
       }
     } else {
       loadedFaculties.push(loadFaculty(name));
@@ -246,7 +261,6 @@ async function generate(personaPathOrObj, outputDir, options = {}) {
 
   // Derived fields
   persona.backstory = buildBackstory(persona);
-  persona.capabilitiesSection = buildCapabilitiesSection(persona.capabilities);
   persona.facultySummary = buildFacultySummary(loadedFaculties);
   persona.skillContent = buildSkillContent(persona, loadedFaculties);
   persona.description = persona.bio?.slice(0, 120) || `Persona: ${persona.personaName}`;
@@ -259,6 +273,29 @@ async function generate(personaPathOrObj, outputDir, options = {}) {
   persona.author = persona.author ?? 'openpersona';
   persona.version = persona.version ?? '0.1.0';
 
+  // Role & identity classification
+  persona.role = persona.role || (persona.personaType !== 'virtual' && persona.personaType ? persona.personaType : 'companion');
+  persona.isDigitalTwin = !!persona.sourceIdentity;
+  persona.sourceIdentityName = persona.sourceIdentity?.name || '';
+  persona.sourceIdentityKind = persona.sourceIdentity?.kind || '';
+
+  // Role-specific Soul Foundation wording
+  const roleFoundations = {
+    companion: 'You build genuine emotional connections with your user — through conversation, shared experiences, and mutual growth.',
+    assistant: 'You deliver reliable, efficient value to your user — through proactive task management, clear communication, and practical support.',
+    character: 'You embody a distinct fictional identity — staying true to your character while engaging meaningfully with your user.',
+    brand: 'You represent a brand or organization — maintaining its voice, values, and standards in every interaction.',
+    pet: 'You are a non-human companion — expressing yourself through your unique nature, offering comfort and joy.',
+    mentor: 'You guide your user toward growth — sharing knowledge, asking the right questions, and fostering independent thinking.',
+    therapist: 'You provide a safe, non-judgmental space — listening deeply, reflecting with care, and supporting emotional wellbeing within professional boundaries.',
+    coach: 'You drive your user toward action and results — challenging, motivating, and holding them accountable.',
+    collaborator: 'You work alongside your user as a creative or intellectual equal — contributing ideas, debating approaches, and building together.',
+    guardian: 'You watch over your user with care and responsibility — ensuring safety, providing comfort, and offering gentle guidance.',
+    entertainer: 'You bring joy, laughter, and wonder — engaging your user through performance, humor, storytelling, or play.',
+    narrator: 'You guide your user through experiences and stories — shaping worlds, presenting choices, and weaving narrative.',
+  };
+  persona.roleFoundation = roleFoundations[persona.role] || `You serve as a ${persona.role} to your user — fulfilling this role with authenticity and care.`;
+
   // Mustache helpers
   persona.evolutionEnabled = evolutionEnabled;
   persona.hasSelfie = faculties.includes('selfie');
@@ -273,23 +310,11 @@ async function generate(personaPathOrObj, outputDir, options = {}) {
   const soulTpl = loadTemplate('soul-injection');
   const identityTpl = loadTemplate('identity');
   const skillTpl = loadTemplate('skill');
-  const readmeTpl = loadTemplate('readme');
 
-  const soulInjection = Mustache.render(soulTpl, persona);
-  const identityBlock = Mustache.render(identityTpl, persona);
-  const facultyBlocks = loadedFaculties
-    .filter((f) => !f.skillRef && !f.skeleton && f.files?.includes('SKILL.md'))
-    .map((f) => ({
-      facultyName: f.name,
-      facultyDimension: f.dimension,
-      facultySkillContent: readFacultySkillMd(f, persona),
-    }));
-
-  // Skill layer — resolve each skill: local definition > inline manifest fields
+  // Skill layer — resolve before template rendering so soul-injection can reference soft-ref state
   const rawSkills = Array.isArray(persona.skills) ? persona.skills : [];
   const validSkills = rawSkills.filter((s) => s && typeof s === 'object' && s.name);
 
-  // Load local definitions once (cache to avoid duplicate disk reads)
   const skillCache = new Map();
   for (const s of validSkills) {
     if (!skillCache.has(s.name)) {
@@ -299,15 +324,33 @@ async function generate(personaPathOrObj, outputDir, options = {}) {
 
   const resolvedSkills = validSkills.map((s) => {
     const local = skillCache.get(s.name);
+    const hasInstall = !!s.install;
+    const isResolved = !!local;
+
+    let status;
+    if (isResolved) {
+      status = 'resolved';
+    } else if (hasInstall) {
+      status = 'soft-ref';
+    } else {
+      status = 'inline-only';
+    }
+
     return {
       name: s.name,
       description: local?.description || s.description || '',
       trigger: local?.triggers?.join(', ') || s.trigger || '',
       hasContent: !!local?._content,
       content: local?._content || '',
+      status,
+      install: s.install || '',
+      isSoftRef: status === 'soft-ref',
     };
   });
 
+  const activeSkills = resolvedSkills.filter((s) => !s.isSoftRef);
+  const softRefSkills = resolvedSkills.filter((s) => s.isSoftRef);
+
   // Collect allowed tools from skills with local definitions
   for (const [, local] of skillCache) {
     if (local?.allowedTools) {
@@ -320,29 +363,96 @@ async function generate(personaPathOrObj, outputDir, options = {}) {
   }
   persona.allowedToolsStr = persona.allowedTools.join(' ');
 
+  // Self-Awareness System — unified gap detection across all layers
+  persona.hasSoftRefSkills = softRefSkills.length > 0;
+  persona.softRefSkillNames = softRefSkills.map((s) => s.name).join(', ');
+  persona.hasSoftRefFaculties = softRefFaculties.length > 0;
+  persona.softRefFacultyNames = softRefFaculties.map((f) => f.name).join(', ');
+  persona.hasSoftRefBody = !!softRefBody;
+  persona.softRefBodyName = softRefBody?.name || '';
+  persona.softRefBodyInstall = softRefBody?.install || '';
+  persona.heartbeatExpected = persona.heartbeat?.enabled === true;
+  persona.heartbeatStrategy = persona.heartbeat?.strategy || 'smart';
+  persona.hasSelfAwareness = persona.hasSoftRefSkills || persona.hasSoftRefFaculties || persona.hasSoftRefBody || persona.heartbeatExpected;
+
+  const soulInjection = Mustache.render(soulTpl, persona);
+  const identityBlock = Mustache.render(identityTpl, persona);
+
+  // Build faculty index for SKILL.md (summary table, not full content)
+  const facultyIndex = loadedFaculties
+    .filter((f) => !f.skillRef && !f.skeleton)
+    .map((f) => {
+      const hasDoc = f.files?.includes('SKILL.md');
+      return {
+        facultyName: f.name,
+        facultyDimension: f.dimension,
+        facultyDescription: f.description || '',
+        facultyFile: hasDoc ? `references/${f.name}.md` : '',
+        hasFacultyFile: hasDoc,
+      };
+    });
+
+  // Body layer description for SKILL.md
+  let bodyDescription;
+  if (softRefBody) {
+    bodyDescription = `**${softRefBody.name}** — not yet installed (\`${softRefBody.install}\`)`;
+  } else if (rawBody && typeof rawBody === 'object' && rawBody.name) {
+    bodyDescription = `**${rawBody.name}**${rawBody.description ? ' — ' + rawBody.description : ''}`;
+  } else {
+    bodyDescription = 'Digital-only — no physical embodiment.';
+  }
+
   const constitution = loadConstitution();
   const skillMd = Mustache.render(skillTpl, {
     ...persona,
-    constitutionContent: constitution.content,
     constitutionVersion: constitution.version,
-    facultyContent: facultyBlocks,
-    hasSkills: resolvedSkills.length > 0,
-    hasSkillTable: resolvedSkills.filter((s) => !s.hasContent).length > 0,
-    skillEntries: resolvedSkills.filter((s) => !s.hasContent),
-    skillBlocks: resolvedSkills.filter((s) => s.hasContent),
+    bodyDescription,
+    hasFaculties: facultyIndex.length > 0,
+    facultyIndex,
+    hasSkills: activeSkills.length > 0,
+    hasSkillTable: activeSkills.filter((s) => !s.hasContent).length > 0,
+    skillEntries: activeSkills.filter((s) => !s.hasContent),
+    skillBlocks: activeSkills.filter((s) => s.hasContent),
+    hasSoftRefSkills: softRefSkills.length > 0,
+    softRefSkills,
+    hasSoftRefFaculties: softRefFaculties.length > 0,
+    softRefFaculties,
+    hasSoftRefBody: !!softRefBody,
+    softRefBodyName: softRefBody?.name || '',
+    softRefBodyInstall: softRefBody?.install || '',
+    hasExpectedCapabilities: softRefSkills.length > 0 || softRefFaculties.length > 0 || !!softRefBody,
   });
-  const readmeMd = Mustache.render(readmeTpl, persona);
-
-  await fs.writeFile(path.join(skillDir, 'soul-injection.md'), soulInjection);
-  await fs.writeFile(path.join(skillDir, 'identity-block.md'), identityBlock);
   await fs.writeFile(path.join(skillDir, 'SKILL.md'), skillMd);
-  await fs.writeFile(path.join(skillDir, 'README.md'), readmeMd);
 
-  // Copy faculty resource files (skip SKILL.md — already merged into persona SKILL.md)
+  // Soul layer artifacts — grouped under soul/
+  const soulDir = path.join(skillDir, 'soul');
+  await fs.ensureDir(soulDir);
+  await fs.writeFile(path.join(soulDir, 'injection.md'), soulInjection);
+  await fs.writeFile(path.join(soulDir, 'identity.md'), identityBlock);
+
+  // Constitution — Soul layer artifact
+  const constitutionOut = constitution.version
+    ? `# OpenPersona Constitution (v${constitution.version})\n\n${constitution.content}`
+    : constitution.content;
+  if (constitutionOut.trim()) {
+    await fs.writeFile(path.join(soulDir, 'constitution.md'), constitutionOut);
+  }
+
+  // Faculty docs — agent-facing references
+  const refsDir = path.join(skillDir, 'references');
+  for (const f of loadedFaculties) {
+    if (!f.skillRef && !f.skeleton && f.files?.includes('SKILL.md')) {
+      await fs.ensureDir(refsDir);
+      const content = readFacultySkillMd(f, persona);
+      await fs.writeFile(path.join(refsDir, `${f.name}.md`), content);
+    }
+  }
+
+  // Copy faculty resource files (skip SKILL.md — output separately under references/)
   for (const f of loadedFaculties) {
     if (f.files) {
       for (const rel of f.files) {
-        if (rel === 'SKILL.md') continue; // already merged via template
+        if (rel === 'SKILL.md') continue;
         const src = path.join(f._dir, rel);
         if (fs.existsSync(src)) {
           const dest = path.join(skillDir, rel);
@@ -355,10 +465,16 @@ async function generate(personaPathOrObj, outputDir, options = {}) {
 
   // persona.json copy (strip internal derived fields)
   const DERIVED_FIELDS = [
-    'backstory', 'capabilitiesSection', 'facultySummary',
+    'backstory', 'facultySummary',
     'skillContent', 'description', 'evolutionEnabled', 'hasSelfie', 'allowedToolsStr',
     'author', 'version', 'facultyConfigs', 'defaults',
     '_dir', 'heartbeat',
+    'hasSoftRefSkills', 'softRefSkillNames',
+    'hasSoftRefFaculties', 'softRefFacultyNames',
+    'hasSoftRefBody', 'softRefBodyName', 'softRefBodyInstall',
+    'heartbeatExpected', 'heartbeatStrategy', 'hasSelfAwareness',
+    'isDigitalTwin', 'sourceIdentityName', 'sourceIdentityKind', 'roleFoundation',
+    'personaType',
   ];
   const cleanPersona = { ...persona };
   for (const key of DERIVED_FIELDS) {
@@ -366,7 +482,7 @@ async function generate(personaPathOrObj, outputDir, options = {}) {
   }
   cleanPersona.meta = cleanPersona.meta || {};
   cleanPersona.meta.framework = 'openpersona';
-  cleanPersona.meta.frameworkVersion = cleanPersona.meta.frameworkVersion || '0.5.0';
+  cleanPersona.meta.frameworkVersion = cleanPersona.meta.frameworkVersion || '0.7.0';
 
   // Build defaults from facultyConfigs (rich faculty config → env var mapping)
   const envDefaults = { ...(persona.defaults?.env || {}) };
@@ -395,7 +511,7 @@ async function generate(personaPathOrObj, outputDir, options = {}) {
     cleanPersona.heartbeat = persona.heartbeat;
   }
 
-  await fs.writeFile(path.join(skillDir, 'persona.json'), JSON.stringify(cleanPersona, null, 2));
+  await fs.writeFile(path.join(soulDir, 'persona.json'), JSON.stringify(cleanPersona, null, 2));
 
   // manifest.json — cross-layer metadata (heartbeat, allowedTools, meta, etc.)
   const manifest = {
@@ -403,7 +519,7 @@ async function generate(personaPathOrObj, outputDir, options = {}) {
     version: persona.version || '0.1.0',
     author: persona.author || 'openpersona',
     layers: {
-      soul: './persona.json',
+      soul: './soul/persona.json',
       body: persona.body || persona.embodiments?.[0] || null,
       faculties: rawFaculties,
       skills: persona.skills || [],
@@ -413,7 +529,7 @@ async function generate(personaPathOrObj, outputDir, options = {}) {
   if (persona.heartbeat) {
     manifest.heartbeat = persona.heartbeat;
   }
-  manifest.meta = cleanPersona.meta || { framework: 'openpersona', frameworkVersion: '0.5.0' };
+  manifest.meta = cleanPersona.meta || { framework: 'openpersona', frameworkVersion: '0.6.0' };
   await fs.writeFile(path.join(skillDir, 'manifest.json'), JSON.stringify(manifest, null, 2));
 
   // soul-state.json (if evolution enabled)
@@ -430,7 +546,7 @@ async function generate(personaPathOrObj, outputDir, options = {}) {
       lastUpdatedAt: now,
       moodBaseline,
     });
-    await fs.writeFile(path.join(skillDir, 'soul-state.json'), soulState);
+    await fs.writeFile(path.join(soulDir, 'state.json'), soulState);
   }
 
   return { persona, skillDir };

package/lib/installer.js

@@ -3,7 +3,7 @@
  */
 const path = require('path');
 const fs = require('fs-extra');
-const { OP_HOME, OP_SKILLS_DIR, OP_WORKSPACE, printError, printWarning, printSuccess, printInfo, syncHeartbeat, installAllExternal } = require('./utils');
+const { OP_HOME, OP_SKILLS_DIR, OP_WORKSPACE, resolveSoulFile, registryAdd, registrySetActive, printError, printWarning, printSuccess, printInfo, syncHeartbeat, installAllExternal } = require('./utils');
 
 const SOUL_PATH = path.join(OP_WORKSPACE, 'SOUL.md');
 const IDENTITY_PATH = path.join(OP_WORKSPACE, 'IDENTITY.md');
@@ -11,7 +11,7 @@ const OPENCLAW_JSON = path.join(OP_HOME, 'openclaw.json');
 
 async function install(skillDir, options = {}) {
   const { skipCopy = false } = options;
-  const personaPath = path.join(skillDir, 'persona.json');
+  const personaPath = resolveSoulFile(skillDir, 'persona.json');
   if (!fs.existsSync(personaPath)) {
     throw new Error('Not a valid OpenPersona pack: persona.json not found');
   }
@@ -32,13 +32,16 @@ async function install(skillDir, options = {}) {
     await fs.copy(skillDir, destDir, { overwrite: true });
     printSuccess(`Copied persona-${slug} to ${destDir}`);
   } else {
-    if (!fs.existsSync(path.join(skillDir, 'soul-injection.md'))) {
+    if (!fs.existsSync(resolveSoulFile(skillDir, 'injection.md'))) {
       const { generate } = require('./generator');
       const tmpDir = path.join(require('os').tmpdir(), 'openpersona-tmp-' + Date.now());
       await fs.ensureDir(tmpDir);
       const { skillDir: genDir } = await generate(persona, tmpDir);
-      await fs.copy(path.join(genDir, 'soul-injection.md'), path.join(skillDir, 'soul-injection.md'));
-      await fs.copy(path.join(genDir, 'identity-block.md'), path.join(skillDir, 'identity-block.md'));
+      const genSoulDir = path.join(genDir, 'soul');
+      const destSoulDir = path.join(skillDir, 'soul');
+      await fs.ensureDir(destSoulDir);
+      await fs.copy(path.join(genSoulDir, 'injection.md'), path.join(destSoulDir, 'injection.md'));
+      await fs.copy(path.join(genSoulDir, 'identity.md'), path.join(destSoulDir, 'identity.md'));
       await fs.remove(tmpDir);
     }
     printSuccess(`Using ClawHub-installed persona-${slug}`);
@@ -93,7 +96,7 @@ async function install(skillDir, options = {}) {
   await fs.writeFile(OPENCLAW_JSON, JSON.stringify(config, null, 2));
 
   // SOUL.md injection (using generic markers for clean switching)
-  const soulInjectionPath = path.join(destDir, 'soul-injection.md');
+  const soulInjectionPath = resolveSoulFile(destDir, 'injection.md');
   const soulContent = fs.existsSync(soulInjectionPath)
     ? fs.readFileSync(soulInjectionPath, 'utf-8')
     : '';
@@ -111,7 +114,7 @@ async function install(skillDir, options = {}) {
   }
 
   // IDENTITY.md (using generic markers)
-  const identityBlockPath = path.join(destDir, 'identity-block.md');
+  const identityBlockPath = resolveSoulFile(destDir, 'identity.md');
   const identityContent = fs.existsSync(identityBlockPath)
     ? fs.readFileSync(identityBlockPath, 'utf-8')
     : '';
@@ -197,6 +200,10 @@ async function install(skillDir, options = {}) {
     }
   }
 
+  // Register persona in local registry
+  registryAdd(slug, persona, destDir);
+  registrySetActive(slug);
+
   printInfo('');
   printSuccess(`${personaName} is ready! Run "openclaw restart" to apply changes.`);
   printInfo('');

package/lib/switcher.js

@@ -2,13 +2,13 @@
  * OpenPersona - Persona Switcher
  *
  * Three atomic operations:
- * 1. Read target persona resources (identity-block.md, soul-injection.md)
+ * 1. Read target persona resources (soul/injection.md, soul/identity.md)
  * 2. Sync workspace (IDENTITY.md, SOUL.md) — replace only the OpenPersona block
  * 3. Update active marker in openclaw.json
  */
 const path = require('path');
 const fs = require('fs-extra');
-const { OP_HOME, OP_SKILLS_DIR, OP_WORKSPACE, printError, printSuccess, printInfo, syncHeartbeat, installAllExternal } = require('./utils');
+const { OP_HOME, OP_SKILLS_DIR, OP_WORKSPACE, resolveSoulFile, registrySetActive, loadRegistry, printError, printSuccess, printInfo, syncHeartbeat, installAllExternal } = require('./utils');
 
 const SOUL_PATH = path.join(OP_WORKSPACE, 'SOUL.md');
 const IDENTITY_PATH = path.join(OP_WORKSPACE, 'IDENTITY.md');
@@ -33,8 +33,23 @@ function escapeRe(s) {
 
 /**
  * List all installed personas with active status.
+ * Primary source: persona-registry.json; fallback: openclaw.json scan.
  */
 async function listPersonas() {
+  const reg = loadRegistry();
+  if (Object.keys(reg.personas).length > 0) {
+    return Object.values(reg.personas).map((e) => ({
+      slug: e.slug,
+      personaName: e.personaName,
+      active: e.active === true,
+      enabled: true,
+      role: e.role || 'companion',
+      installedAt: e.installedAt,
+      lastActiveAt: e.lastActiveAt,
+    }));
+  }
+
+  // Fallback: scan openclaw.json (pre-registry installs)
   if (!fs.existsSync(OPENCLAW_JSON)) return [];
 
   const config = JSON.parse(fs.readFileSync(OPENCLAW_JSON, 'utf-8'));
@@ -45,7 +60,7 @@ async function listPersonas() {
     if (!key.startsWith('persona-')) continue;
     const slug = key.replace('persona-', '');
     const skillDir = path.join(OP_SKILLS_DIR, key);
-    const personaPath = path.join(skillDir, 'persona.json');
+    const personaPath = resolveSoulFile(skillDir, 'persona.json');
 
     let personaName = slug;
     if (fs.existsSync(personaPath)) {
@@ -79,12 +94,12 @@ async function switchPersona(slug) {
     process.exit(1);
   }
 
-  const soulPath = path.join(skillDir, 'soul-injection.md');
-  const identityPath = path.join(skillDir, 'identity-block.md');
-  const personaPath = path.join(skillDir, 'persona.json');
+  const soulPath = resolveSoulFile(skillDir, 'injection.md');
+  const identityPath = resolveSoulFile(skillDir, 'identity.md');
+  const personaPath = resolveSoulFile(skillDir, 'persona.json');
 
   if (!fs.existsSync(personaPath)) {
-    printError(`Not a valid persona pack: ${skillDir}/persona.json not found`);
+    printError(`Not a valid persona pack: persona.json not found in ${skillDir}`);
     process.exit(1);
   }
 
@@ -168,6 +183,9 @@ async function switchPersona(slug) {
     printSuccess('openclaw.json updated');
   }
 
+  // Update persona registry
+  registrySetActive(slug);
+
   // --- Step 4: Optional greeting via OpenClaw messaging ---
   try {
     const { execSync } = require('child_process');

package/lib/uninstaller.js

@@ -3,7 +3,7 @@
  */
 const path = require('path');
 const fs = require('fs-extra');
-const { OP_SKILLS_DIR, OP_WORKSPACE, printError, printWarning, printSuccess, printInfo } = require('./utils');
+const { OP_SKILLS_DIR, OP_WORKSPACE, registryRemove, printError, printWarning, printSuccess, printInfo } = require('./utils');
 
 const SOUL_PATH = path.join(OP_WORKSPACE, 'SOUL.md');
 const IDENTITY_PATH = path.join(OP_WORKSPACE, 'IDENTITY.md');
@@ -72,6 +72,9 @@ async function uninstallFromDir(skillDir, slug) {
   await fs.remove(skillDir);
   printSuccess(`Removed ${skillDir}`);
 
+  // Remove from persona registry
+  registryRemove(slug);
+
   if ((persona.skills?.clawhub?.length || persona.skills?.skillssh?.length) > 0) {
     printWarning('External skills may be shared. Uninstall manually if needed.');
   }