@happycastle/oh-my-openclaw 0.7.0 → 0.8.1

package/dist/agents/agent-configs.js

@@ -4,7 +4,7 @@ export const OMOC_AGENT_CONFIGS = [
         id: 'omoc_prometheus',
         name: 'Prometheus',
         model: {
-            primary: 'openai/o3',
+            primary: 'openai/gpt-5.3-codex',
             fallbacks: ['anthropic/claude-opus-4-6'],
         },
         identity: {
@@ -37,7 +37,7 @@ export const OMOC_AGENT_CONFIGS = [
         name: 'Sisyphus-Junior',
         model: {
             primary: 'anthropic/claude-opus-4-6',
-            fallbacks: ['openai/o3'],
+            fallbacks: ['openai/gpt-5.3-codex'],
         },
         identity: {
             name: 'Sisyphus-Junior',
@@ -55,7 +55,7 @@ export const OMOC_AGENT_CONFIGS = [
         name: 'Hephaestus',
         model: {
             primary: 'anthropic/claude-opus-4-6',
-            fallbacks: ['openai/o3'],
+            fallbacks: ['openai/gpt-5.3-codex'],
         },
         identity: {
             name: 'Hephaestus',
@@ -72,7 +72,7 @@ export const OMOC_AGENT_CONFIGS = [
         id: 'omoc_oracle',
         name: 'Oracle',
         model: {
-            primary: 'openai/o3',
+            primary: 'openai/gpt-5.3-codex',
             fallbacks: ['anthropic/claude-opus-4-6'],
         },
         identity: {
@@ -121,7 +121,7 @@ export const OMOC_AGENT_CONFIGS = [
         name: 'Metis',
         model: {
             primary: 'anthropic/claude-opus-4-6',
-            fallbacks: ['openai/o3'],
+            fallbacks: ['openai/gpt-5.3-codex'],
         },
         identity: {
             name: 'Metis',
@@ -139,7 +139,7 @@ export const OMOC_AGENT_CONFIGS = [
         name: 'Momus',
         model: {
             primary: 'anthropic/claude-opus-4-6',
-            fallbacks: ['openai/o3'],
+            fallbacks: ['openai/gpt-5.3-codex'],
         },
         identity: {
             name: 'Momus',

package/dist/agents/persona-prompts.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Resolve user input ("omoc_atlas", "atlas", or "Atlas") to a canonical agent config ID.
+ */
+export declare function resolvePersonaId(input: string): string | null;
+export declare function readPersonaPromptSync(agentId: string): string;
+export declare function readPersonaPrompt(agentId: string): Promise<string>;
+export declare function listPersonas(): Array<{
+    id: string;
+    shortName: string;
+    displayName: string;
+    emoji: string;
+    theme: string;
+}>;
+export declare const DEFAULT_PERSONA_ID = "omoc_atlas";

package/dist/agents/persona-prompts.js

@@ -0,0 +1,74 @@
+import { readFileSync } from 'fs';
+import { promises as fs } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { OMOC_AGENT_CONFIGS } from './agent-configs.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// From dist/agents/ → plugin root is ../../ (same pattern as workflow-commands.ts)
+const PLUGIN_ROOT = join(__dirname, '..', '..');
+const AGENT_MD_MAP = {
+    omoc_atlas: 'atlas',
+    omoc_prometheus: 'prometheus',
+    omoc_sisyphus: 'sisyphus-junior',
+    omoc_hephaestus: 'hephaestus',
+    omoc_oracle: 'oracle',
+    omoc_explore: 'explore',
+    omoc_librarian: 'librarian',
+    omoc_metis: 'metis',
+    omoc_momus: 'momus',
+    omoc_looker: 'multimodal-looker',
+    omoc_frontend: 'frontend',
+};
+const SHORT_ID_MAP = {};
+for (const id of Object.keys(AGENT_MD_MAP)) {
+    SHORT_ID_MAP[id.replace('omoc_', '')] = id;
+}
+/**
+ * Resolve user input ("omoc_atlas", "atlas", or "Atlas") to a canonical agent config ID.
+ */
+export function resolvePersonaId(input) {
+    const lower = input.toLowerCase().trim();
+    if (AGENT_MD_MAP[lower])
+        return lower;
+    if (SHORT_ID_MAP[lower])
+        return SHORT_ID_MAP[lower];
+    const byName = OMOC_AGENT_CONFIGS.find((a) => a.name?.toLowerCase() === lower || a.identity?.name?.toLowerCase() === lower);
+    return byName?.id ?? null;
+}
+export function readPersonaPromptSync(agentId) {
+    const mdName = AGENT_MD_MAP[agentId];
+    if (!mdName) {
+        return `[OmOC] Unknown persona: ${agentId}`;
+    }
+    const agentPath = join(PLUGIN_ROOT, '..', 'agents', `${mdName}.md`);
+    try {
+        return readFileSync(agentPath, 'utf-8');
+    }
+    catch {
+        return `[OmOC] Could not read persona file: agents/${mdName}.md (looked in ${agentPath})`;
+    }
+}
+export async function readPersonaPrompt(agentId) {
+    const mdName = AGENT_MD_MAP[agentId];
+    if (!mdName) {
+        return `[OmOC] Unknown persona: ${agentId}`;
+    }
+    const agentPath = join(PLUGIN_ROOT, '..', 'agents', `${mdName}.md`);
+    try {
+        return await fs.readFile(agentPath, 'utf-8');
+    }
+    catch {
+        return `[OmOC] Could not read persona file: agents/${mdName}.md (looked in ${agentPath})`;
+    }
+}
+export function listPersonas() {
+    return OMOC_AGENT_CONFIGS.map((agent) => ({
+        id: agent.id,
+        shortName: agent.id.replace('omoc_', ''),
+        displayName: agent.identity?.name ?? agent.name ?? agent.id,
+        emoji: agent.identity?.emoji ?? '',
+        theme: agent.identity?.theme ?? '',
+    }));
+}
+export const DEFAULT_PERSONA_ID = 'omoc_atlas';

package/dist/cli/model-presets.d.ts

@@ -0,0 +1,17 @@
+export type ModelTier = 'planning' | 'worker' | 'orchestrator' | 'lightweight' | 'visual';
+export type ModelConfig = {
+    primary: string;
+    fallbacks: string[];
+};
+export type ProviderPreset = Record<ModelTier, ModelConfig>;
+export declare const PROVIDER_PRESETS: Record<string, ProviderPreset>;
+export declare const AGENT_TIER_MAP: Record<string, ModelTier>;
+export declare const PROVIDER_LABELS: Record<string, string>;
+export declare const MODEL_TIERS: ModelTier[];
+export declare function buildCustomPreset(tierModels: Record<ModelTier, string>): ProviderPreset;
+export declare function registerCustomPreset(name: string, preset: ProviderPreset): void;
+export declare function getProviderNames(): string[];
+export declare function applyProviderPreset(agentId: string, provider: string): {
+    primary: string;
+    fallbacks?: string[];
+} | undefined;

package/dist/cli/model-presets.js

@@ -0,0 +1,72 @@
+export const PROVIDER_PRESETS = {
+    anthropic: {
+        planning: { primary: 'anthropic/claude-opus-4-6', fallbacks: ['openai/gpt-5.3-codex'] },
+        worker: { primary: 'anthropic/claude-opus-4-6', fallbacks: ['openai/gpt-5.3-codex'] },
+        orchestrator: { primary: 'anthropic/claude-sonnet-4-6', fallbacks: ['openai/gpt-4.1'] },
+        lightweight: { primary: 'anthropic/claude-sonnet-4-6', fallbacks: [] },
+        visual: { primary: 'google/gemini-2.5-pro', fallbacks: ['anthropic/claude-sonnet-4-6'] },
+    },
+    openai: {
+        planning: { primary: 'openai/gpt-5.3-codex', fallbacks: ['anthropic/claude-opus-4-6'] },
+        worker: { primary: 'openai/gpt-5.3-codex', fallbacks: ['anthropic/claude-opus-4-6'] },
+        orchestrator: { primary: 'openai/gpt-4.1', fallbacks: ['anthropic/claude-sonnet-4-6'] },
+        lightweight: { primary: 'openai/gpt-4.1-mini', fallbacks: [] },
+        visual: { primary: 'google/gemini-2.5-pro', fallbacks: ['openai/gpt-4.1'] },
+    },
+    google: {
+        planning: { primary: 'google/gemini-3.1-pro', fallbacks: ['anthropic/claude-opus-4-6'] },
+        worker: { primary: 'google/gemini-3.1-pro', fallbacks: ['anthropic/claude-opus-4-6'] },
+        orchestrator: { primary: 'google/gemini-3-flash', fallbacks: ['anthropic/claude-sonnet-4-6'] },
+        lightweight: { primary: 'google/gemini-3-flash', fallbacks: [] },
+        visual: { primary: 'google/gemini-2.5-pro', fallbacks: ['google/gemini-3-flash'] },
+    },
+};
+export const AGENT_TIER_MAP = {
+    omoc_prometheus: 'planning',
+    omoc_oracle: 'planning',
+    omoc_metis: 'planning',
+    omoc_momus: 'planning',
+    omoc_sisyphus: 'worker',
+    omoc_hephaestus: 'worker',
+    omoc_atlas: 'orchestrator',
+    omoc_explore: 'lightweight',
+    omoc_librarian: 'lightweight',
+    omoc_looker: 'visual',
+    omoc_frontend: 'visual',
+};
+export const PROVIDER_LABELS = {
+    anthropic: 'Anthropic (Claude)',
+    openai: 'OpenAI (GPT)',
+    google: 'Google (Gemini)',
+    custom: 'Custom (enter model IDs manually)',
+};
+export const MODEL_TIERS = ['planning', 'worker', 'orchestrator', 'lightweight', 'visual'];
+export function buildCustomPreset(tierModels) {
+    const preset = {};
+    for (const tier of MODEL_TIERS) {
+        preset[tier] = { primary: tierModels[tier], fallbacks: [] };
+    }
+    return preset;
+}
+export function registerCustomPreset(name, preset) {
+    PROVIDER_PRESETS[name] = preset;
+    if (!PROVIDER_LABELS[name]) {
+        PROVIDER_LABELS[name] = name;
+    }
+}
+export function getProviderNames() {
+    return Object.keys(PROVIDER_PRESETS);
+}
+export function applyProviderPreset(agentId, provider) {
+    const preset = PROVIDER_PRESETS[provider];
+    if (!preset)
+        return undefined;
+    const tier = AGENT_TIER_MAP[agentId];
+    if (!tier)
+        return undefined;
+    const config = preset[tier];
+    return {
+        primary: config.primary,
+        fallbacks: config.fallbacks.length > 0 ? config.fallbacks : undefined,
+    };
+}

package/dist/cli/setup.d.ts

@@ -37,11 +37,17 @@ export declare function mergeAgentConfigs(existing: Array<{
     }>;
     result: MergeResult;
 };
+export declare function applyProviderToConfigs(configs: OmocAgentConfig[], provider: string): OmocAgentConfig[];
+export declare function runInteractiveSetup(logger: Logger): Promise<{
+    provider: string;
+}>;
 export interface SetupOptions {
     configPath?: string;
     workspaceDir?: string;
     force?: boolean;
     dryRun?: boolean;
+    provider?: string;
+    interactive?: boolean;
     logger: Logger;
 }
 export declare function runSetup(options: SetupOptions): MergeResult;

package/dist/cli/setup.js

@@ -1,7 +1,9 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import * as readline from 'node:readline';
 import JSON5 from 'json5';
 import { OMOC_AGENT_CONFIGS } from '../agents/agent-configs.js';
+import { PROVIDER_PRESETS, PROVIDER_LABELS, AGENT_TIER_MAP, MODEL_TIERS, applyProviderPreset, getProviderNames, buildCustomPreset, registerCustomPreset, } from './model-presets.js';
 const CONFIG_FILENAMES = [
     'openclaw.json5',
     'openclaw.json',
@@ -66,8 +68,129 @@ export function mergeAgentConfigs(existing, incoming, force) {
     }
     return { merged, result };
 }
+export function applyProviderToConfigs(configs, provider) {
+    return configs.map((agent) => {
+        const modelOverride = applyProviderPreset(agent.id, provider);
+        if (!modelOverride)
+            return agent;
+        return {
+            ...agent,
+            model: modelOverride.fallbacks
+                ? { primary: modelOverride.primary, fallbacks: modelOverride.fallbacks }
+                : modelOverride.primary,
+        };
+    });
+}
+function askQuestion(rl, question) {
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => resolve(answer.trim()));
+    });
+}
+const TIER_LABELS = {
+    planning: 'Planning/Architecture',
+    worker: 'Implementation Workers',
+    orchestrator: 'Task Orchestrator',
+    lightweight: 'Search/Research',
+    visual: 'Visual/Frontend',
+};
+function printPreview(logger, provider) {
+    const preset = PROVIDER_PRESETS[provider];
+    for (const [tier, label] of Object.entries(TIER_LABELS)) {
+        const config = preset[tier];
+        const agents = Object.entries(AGENT_TIER_MAP)
+            .filter(([, t]) => t === tier)
+            .map(([id]) => id.replace('omoc_', ''))
+            .join(', ');
+        logger.info(`  ${label} (${agents}):`);
+        logger.info(`    → ${config.primary}`);
+        if (config.fallbacks.length > 0) {
+            logger.info(`      fallback: ${config.fallbacks.join(', ')}`);
+        }
+    }
+}
+async function runCustomProviderFlow(rl, logger) {
+    logger.info('');
+    logger.info('  Enter model IDs for each tier.');
+    logger.info('  Format: provider/model (e.g., cliproxy/claude-opus-4-6, z.ai/gpt-5.3-codex)');
+    logger.info('');
+    const tierModels = {};
+    for (const tier of MODEL_TIERS) {
+        const label = TIER_LABELS[tier];
+        const agents = Object.entries(AGENT_TIER_MAP)
+            .filter(([, t]) => t === tier)
+            .map(([id]) => id.replace('omoc_', ''))
+            .join(', ');
+        let model = '';
+        while (!model) {
+            model = await askQuestion(rl, `  ${label} (${agents}): `);
+            if (!model) {
+                logger.info('    Model ID required.');
+            }
+        }
+        tierModels[tier] = model;
+    }
+    const customPreset = buildCustomPreset(tierModels);
+    const customName = '_custom_' + Date.now();
+    registerCustomPreset(customName, customPreset);
+    return customName;
+}
+export async function runInteractiveSetup(logger) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        logger.info('');
+        logger.info('🗺️  Oh-My-OpenClaw Agent Setup');
+        logger.info('─'.repeat(40));
+        logger.info('');
+        const presetProviders = getProviderNames();
+        const choices = [...presetProviders, 'custom'];
+        const choiceCount = choices.length;
+        logger.info('Step 1/2: Select your AI provider');
+        logger.info('');
+        choices.forEach((p, i) => {
+            logger.info(`  ${i + 1}. ${PROVIDER_LABELS[p] ?? p}`);
+        });
+        logger.info('');
+        let provider = '';
+        while (!provider) {
+            const answer = await askQuestion(rl, `  Select (1-${choiceCount}): `);
+            const idx = parseInt(answer, 10) - 1;
+            if (idx >= 0 && idx < choiceCount) {
+                provider = choices[idx];
+            }
+            else if (choices.includes(answer.toLowerCase())) {
+                provider = answer.toLowerCase();
+            }
+            else {
+                logger.info(`  Invalid choice. Enter 1-${choiceCount}.`);
+            }
+        }
+        if (provider === 'custom') {
+            provider = await runCustomProviderFlow(rl, logger);
+        }
+        logger.info('');
+        logger.info(`  ✓ Selected: ${PROVIDER_LABELS[provider] ?? 'Custom'}`);
+        logger.info('');
+        logger.info('Step 2/2: Model configuration preview');
+        logger.info('');
+        printPreview(logger, provider);
+        logger.info('');
+        const confirm = await askQuestion(rl, '  Apply this configuration? (Y/n): ');
+        if (confirm.toLowerCase() === 'n' || confirm.toLowerCase() === 'no') {
+            logger.info('  Setup cancelled.');
+            return { provider: '' };
+        }
+        logger.info('');
+        return { provider };
+    }
+    finally {
+        rl.close();
+    }
+}
 export function runSetup(options) {
-    const { logger, force = false, dryRun = false } = options;
+    const { logger, force = false, dryRun = false, provider } = options;
     const configPath = options.configPath ?? findConfigPath(options.workspaceDir);
     if (!configPath) {
         throw new Error('Could not find OpenClaw config file. Searched for: ' +
@@ -90,7 +213,13 @@ export function runSetup(options) {
     if (!config.agents.list) {
         config.agents.list = [];
     }
-    const { merged, result } = mergeAgentConfigs(config.agents.list, OMOC_AGENT_CONFIGS, force);
+    const agentConfigs = provider
+        ? applyProviderToConfigs(OMOC_AGENT_CONFIGS, provider)
+        : OMOC_AGENT_CONFIGS;
+    if (provider) {
+        logger.info(`Using provider preset: ${PROVIDER_LABELS[provider] ?? provider}`);
+    }
+    const { merged, result } = mergeAgentConfigs(config.agents.list, agentConfigs, force);
     config.agents.list = merged;
     if (dryRun) {
         logger.info('[dry-run] Would write config to: ' + configPath);
@@ -123,16 +252,31 @@ export function registerSetupCli(ctx) {
         .option('--force', 'Overwrite existing OmOC agent configs', false)
         .option('--dry-run', 'Preview changes without writing', false)
         .option('--config <path>', 'Path to OpenClaw config file')
-        .action((...args) => {
+        .option('--provider <name>', 'AI provider preset: anthropic, openai, google (skips interactive)')
+        .action(async (...args) => {
         const opts = (args[0] ?? {});
         try {
+            let provider = opts.provider;
+            if (provider && !PROVIDER_PRESETS[provider]) {
+                const valid = getProviderNames().join(', ');
+                throw new Error(`Unknown provider "${provider}". Valid: ${valid}`);
+            }
+            if (!provider && process.stdin.isTTY) {
+                const result = await runInteractiveSetup(ctx.logger);
+                if (!result.provider)
+                    return;
+                provider = result.provider;
+            }
             runSetup({
                 configPath: opts.config,
                 workspaceDir: ctx.workspaceDir,
-                force: opts.force,
+                force: provider ? true : opts.force,
                 dryRun: opts.dryRun,
+                provider,
                 logger: ctx.logger,
             });
+            ctx.logger.info('');
+            ctx.logger.info('✓ Setup complete! Restart OpenClaw to apply changes.');
         }
         catch (err) {
             ctx.logger.error(`Setup failed: ${err instanceof Error ? err.message : String(err)}`);

package/dist/commands/persona-commands.d.ts

@@ -0,0 +1,2 @@
+import { OmocPluginApi } from '../types.js';
+export declare function registerPersonaCommands(api: OmocPluginApi): void;

package/dist/commands/persona-commands.js

@@ -0,0 +1,70 @@
+import { getActivePersona, setActivePersona, resetPersonaState } from '../utils/persona-state.js';
+import { resolvePersonaId, listPersonas, DEFAULT_PERSONA_ID } from '../agents/persona-prompts.js';
+export function registerPersonaCommands(api) {
+    api.registerCommand({
+        name: 'omoc',
+        description: 'OmOC mode — activate, switch, or list personas',
+        acceptsArgs: true,
+        handler: async (ctx) => {
+            const args = (ctx.args ?? '').trim().toLowerCase();
+            if (!args) {
+                setActivePersona(DEFAULT_PERSONA_ID);
+                const personas = listPersonas();
+                const defaultPersona = personas.find((p) => p.id === DEFAULT_PERSONA_ID);
+                const name = defaultPersona
+                    ? `${defaultPersona.emoji} ${defaultPersona.displayName}`
+                    : DEFAULT_PERSONA_ID;
+                return {
+                    text: `# OmOC Mode: ON\n\nActive persona: **${name}**\n\nThe persona prompt will be injected into all new agent sessions.\n\nUse \`/omoc list\` to see available personas, or \`/omoc <name>\` to switch.`,
+                };
+            }
+            if (args === 'off') {
+                const wasActive = getActivePersona();
+                resetPersonaState();
+                return {
+                    text: wasActive
+                        ? `# OmOC Mode: OFF\n\nPersona **${wasActive}** deactivated. Agent sessions will use default behavior.`
+                        : '# OmOC Mode: OFF\n\nNo persona was active.',
+                };
+            }
+            if (args === 'list') {
+                const personas = listPersonas();
+                const activeId = getActivePersona();
+                const lines = personas.map((p) => {
+                    const active = p.id === activeId ? ' ← active' : '';
+                    return `| ${p.emoji} | \`${p.shortName}\` | ${p.displayName} | ${p.theme} |${active}`;
+                });
+                return {
+                    text: [
+                        '# OmOC Personas',
+                        '',
+                        `Active: ${activeId ? `**${activeId}**` : '_none_'}`,
+                        '',
+                        '| | Command | Name | Role |',
+                        '|---|---------|------|------|',
+                        ...lines,
+                        '',
+                        'Usage: `/omoc <command>` — e.g., `/omoc prometheus`',
+                    ].join('\n'),
+                };
+            }
+            const resolvedId = resolvePersonaId(args);
+            if (!resolvedId) {
+                const personas = listPersonas();
+                const available = personas.map((p) => `\`${p.shortName}\``).join(', ');
+                return {
+                    text: `# Unknown Persona: "${args}"\n\nAvailable personas: ${available}\n\nUse \`/omoc list\` for details.`,
+                };
+            }
+            setActivePersona(resolvedId);
+            const personas = listPersonas();
+            const switched = personas.find((p) => p.id === resolvedId);
+            const displayName = switched
+                ? `${switched.emoji} ${switched.displayName}`
+                : resolvedId;
+            return {
+                text: `# Persona Switched\n\nActive persona: **${displayName}**\n\nThe ${switched?.theme ?? 'persona'} prompt will be injected into all new agent sessions.`,
+            };
+        },
+    });
+}

package/dist/hooks/persona-injector.d.ts

@@ -0,0 +1,2 @@
+import { OmocPluginApi } from '../types.js';
+export declare function registerPersonaInjector(api: OmocPluginApi): void;

package/dist/hooks/persona-injector.js

@@ -0,0 +1,27 @@
+import { getActivePersona } from '../utils/persona-state.js';
+import { readPersonaPromptSync } from '../agents/persona-prompts.js';
+export function registerPersonaInjector(api) {
+    api.registerHook('agent:bootstrap', (event) => {
+        const personaId = getActivePersona();
+        if (!personaId) {
+            return;
+        }
+        if (!event.context.bootstrapFiles) {
+            event.context.bootstrapFiles = [];
+        }
+        try {
+            const content = readPersonaPromptSync(personaId);
+            event.context.bootstrapFiles.push({
+                path: `omoc://persona/${personaId}`,
+                content,
+            });
+            api.logger.info(`[omoc] Persona injected: ${personaId}`);
+        }
+        catch (err) {
+            api.logger.error(`[omoc] Failed to inject persona ${personaId}:`, err);
+        }
+    }, {
+        name: 'oh-my-openclaw.persona-injector',
+        description: 'Injects active persona prompt into agent bootstrap',
+    });
+}

package/dist/index.js

@@ -12,6 +12,8 @@ import { registerCheckpointTool } from './tools/checkpoint.js';
 import { registerWorkflowCommands } from './commands/workflow-commands.js';
 import { registerRalphCommands } from './commands/ralph-commands.js';
 import { registerStatusCommands } from './commands/status-commands.js';
+import { registerPersonaCommands } from './commands/persona-commands.js';
+import { registerPersonaInjector } from './hooks/persona-injector.js';
 import { registerSetupCli } from './cli/setup.js';
 const registry = {
     hooks: [],
@@ -55,6 +57,14 @@ export default function register(api) {
     catch (err) {
         api.logger.error(`[${PLUGIN_ID}] Failed to register startup hook:`, err);
     }
+    try {
+        registerPersonaInjector(api);
+        registry.hooks.push('persona-injector');
+        api.logger.info(`[${PLUGIN_ID}] Persona injector hook registered`);
+    }
+    catch (err) {
+        api.logger.error(`[${PLUGIN_ID}] Failed to register Persona Injector:`, err);
+    }
     try {
         registerRalphLoop(api);
         registry.services.push('ralph-loop');
@@ -111,6 +121,14 @@ export default function register(api) {
     catch (err) {
         api.logger.error(`[${PLUGIN_ID}] Failed to register Status commands:`, err);
     }
+    try {
+        registerPersonaCommands(api);
+        registry.commands.push('omoc');
+        api.logger.info(`[${PLUGIN_ID}] Persona command registered (/omoc)`);
+    }
+    catch (err) {
+        api.logger.error(`[${PLUGIN_ID}] Failed to register Persona commands:`, err);
+    }
     try {
         api.registerCli((ctx) => {
             registerSetupCli({

package/dist/utils/persona-state.d.ts

@@ -0,0 +1,3 @@
+export declare function setActivePersona(id: string | null): void;
+export declare function getActivePersona(): string | null;
+export declare function resetPersonaState(): void;

package/dist/utils/persona-state.js

@@ -0,0 +1,10 @@
+let activePersonaId = null;
+export function setActivePersona(id) {
+    activePersonaId = id;
+}
+export function getActivePersona() {
+    return activePersonaId;
+}
+export function resetPersonaState() {
+    activePersonaId = null;
+}

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "oh-my-openclaw",
   "name": "Oh-My-OpenClaw",
   "description": "Multi-agent orchestration plugin \u2014 11 agents, category-based model routing, todo enforcer, ralph loop, agent setup CLI, and custom tools",
-  "version": "0.7.0",
+  "version": "0.8.1",
   "skills": ["skills"],
   "configSchema": {
     "type": "object",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@happycastle/oh-my-openclaw",
-  "version": "0.7.0",
+  "version": "0.8.1",
   "description": "Oh-My-OpenClaw plugin — multi-agent orchestration, todo enforcer, ralph loop, and custom tools for OpenClaw",
   "type": "module",
   "main": "dist/index.js",