@happycastle/oh-my-openclaw 0.12.3 → 0.12.5

package/dist/commands/persona-commands.js

@@ -1,6 +1,9 @@
 import { getActivePersona, setActivePersona, resetPersonaState } from '../utils/persona-state.js';
 import { resolvePersonaId, listPersonas, DEFAULT_PERSONA_ID } from '../agents/persona-prompts.js';
-import { resetPersonaInjectorState, resetPersonaContextEntries } from '../hooks/persona-injector.js';
+function getDisplayName(personaId) {
+    const persona = listPersonas().find((p) => p.id === personaId);
+    return persona ? `${persona.emoji} ${persona.displayName}` : personaId;
+}
 export function registerPersonaCommands(api) {
     api.registerCommand({
         name: 'omoc',
@@ -11,23 +14,23 @@ export function registerPersonaCommands(api) {
             const args = (ctx.args ?? '').trim().toLowerCase();
             api.logger.info(`[omoc] Parsed args: "${args}" (length: ${args.length})`);
             if (!args) {
+                const previousId = getActivePersona();
                 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;
+                const name = getDisplayName(DEFAULT_PERSONA_ID);
+                const switchNote = previousId && previousId !== DEFAULT_PERSONA_ID
+                    ? `\n\nSwitched from **${getDisplayName(previousId)}**.`
+                    : '';
                 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.`,
+                    text: `# OmOC Mode: ON\n\nActive persona: **${name}**${switchNote}\n\nApplied immediately — your next message will use this persona.\n\nUse \`/omoc list\` to see available personas, or \`/omoc <name>\` to switch.`,
                 };
             }
             if (args === 'off') {
                 const wasActive = getActivePersona();
+                const wasName = wasActive ? getDisplayName(wasActive) : null;
                 resetPersonaState();
-                resetPersonaInjectorState();
                 return {
-                    text: wasActive
-                        ? `# OmOC Mode: OFF\n\nPersona **${wasActive}** deactivated. Agent sessions will use default behavior.`
+                    text: wasName
+                        ? `# OmOC Mode: OFF\n\nPersona **${wasName}** deactivated. Applied immediately — your next message will use default behavior.`
                         : '# OmOC Mode: OFF\n\nNo persona was active.',
                 };
             }
@@ -42,7 +45,7 @@ export function registerPersonaCommands(api) {
                     text: [
                         '# OmOC Personas',
                         '',
-                        `Active: ${activeId ? `**${activeId}**` : '_none_'}`,
+                        `Active: ${activeId ? `**${getDisplayName(activeId)}**` : '_none_'}`,
                         '',
                         '| | Command | Name | Role |',
                         '|---|---------|------|------|',
@@ -60,15 +63,15 @@ export function registerPersonaCommands(api) {
                     text: `# Unknown Persona: "${args}"\n\nAvailable personas: ${available}\n\nUse \`/omoc list\` for details.`,
                 };
             }
-            resetPersonaContextEntries();
+            const previousId = getActivePersona();
             setActivePersona(resolvedId);
-            const personas = listPersonas();
-            const switched = personas.find((p) => p.id === resolvedId);
-            const displayName = switched
-                ? `${switched.emoji} ${switched.displayName}`
-                : resolvedId;
+            const displayName = getDisplayName(resolvedId);
+            const switched = listPersonas().find((p) => p.id === resolvedId);
+            const switchNote = previousId && previousId !== resolvedId
+                ? `\n\nSwitched from **${getDisplayName(previousId)}**.`
+                : '';
             return {
-                text: `# Persona Switched\n\nActive persona: **${displayName}**\n\nThe ${switched?.theme ?? 'persona'} prompt will be injected into all new agent sessions.`,
+                text: `# Persona Switched\n\nActive persona: **${displayName}**${switchNote}\n\nApplied immediately — your next message will use the ${switched?.theme ?? 'persona'} prompt.`,
             };
         },
     });

package/dist/hooks/context-injector.js

@@ -1,21 +1,22 @@
 import { contextCollector } from '../features/context-collector.js';
 export function registerContextInjector(api) {
-    api.registerHook('before_prompt_build', (event) => {
-        const sessionKey = event.agentId || 'default';
+    // Use the typed hook system (api.on) instead of api.registerHook.
+    // api.registerHook registers into the internal hook system which does NOT
+    // trigger before_prompt_build — only hookRunner (typed hooks) does.
+    api.on('before_prompt_build', (_event, ctx) => {
+        const sessionKey = ctx.agentId || 'default';
         if (!contextCollector.hasEntries(sessionKey)) {
-            return event;
+            return;
         }
         const entryCount = contextCollector.getEntries(sessionKey).length;
         const collectedContext = contextCollector.collectAsString(sessionKey);
         if (!collectedContext) {
-            return event;
+            return;
         }
-        const existing = event.prependContext || '';
-        event.prependContext = existing ? `${existing}\n\n${collectedContext}` : collectedContext;
-        api.logger.info(`[omoc] Context injected: ${entryCount} entries for ${sessionKey}`);
-        return event;
-    }, {
-        name: 'oh-my-openclaw.context-injector',
-        description: 'Unified context injection from ContextCollector into prependContext',
-    });
+        api.logger.info(`[omoc] Context injected via before_prompt_build: ${entryCount} entries for ${sessionKey}`);
+        return {
+            prependContext: collectedContext,
+        };
+    }, { priority: 50 } // Lower priority than persona (100) — persona goes first
+    );
 }

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

@@ -1,7 +1,2 @@
 import { OmocPluginApi } from '../types.js';
-export declare function resetPersonaContextEntries(): void;
-export declare function resetPersonaInjectorState(): void;
-export declare function getPersonaInjectorState(): {
-    lastInjectedPersonaId: string | null;
-};
 export declare function registerPersonaInjector(api: OmocPluginApi): void;

package/dist/hooks/persona-injector.js

@@ -1,61 +1,54 @@
 import { getActivePersona } from '../utils/persona-state.js';
-import { readPersonaPromptSync } from '../agents/persona-prompts.js';
-import { contextCollector } from '../features/context-collector.js';
-let lastInjectedPersonaId = null;
-const personaSessionKeys = new Set();
-export function resetPersonaContextEntries() {
-    for (const sessionKey of personaSessionKeys) {
-        const entries = contextCollector.getEntries(sessionKey);
-        for (const entry of entries) {
-            if (entry.source === 'persona') {
-                contextCollector.unregister(sessionKey, entry.id);
-            }
-        }
+import { readPersonaPromptSync, resolvePersonaId } from '../agents/persona-prompts.js';
+/**
+ * Resolve the effective persona ID.
+ *
+ * Priority:
+ *   1. Manually set persona via /omoc command (getActivePersona())
+ *   2. agentId from the hook context (set by OpenClaw core)
+ *   3. null — no persona to inject
+ */
+function resolveEffectivePersona(ctx) {
+    const manual = getActivePersona();
+    if (manual) {
+        const resolved = resolvePersonaId(manual);
+        if (resolved)
+            return { personaId: resolved, source: 'manual' };
     }
-    personaSessionKeys.clear();
-}
-export function resetPersonaInjectorState() {
-    lastInjectedPersonaId = null;
-    resetPersonaContextEntries();
-}
-export function getPersonaInjectorState() {
-    return { lastInjectedPersonaId };
+    const agentId = ctx.agentId;
+    if (!agentId)
+        return null;
+    const resolved = resolvePersonaId(agentId);
+    if (!resolved)
+        return null;
+    return { personaId: resolved, source: 'auto' };
 }
 export function registerPersonaInjector(api) {
-    api.registerHook('agent:bootstrap', (event) => {
-        const personaId = getActivePersona();
-        const sessionKey = event.context.agentId || 'default';
-        if (!personaId) {
-            if (lastInjectedPersonaId) {
-                contextCollector.unregister(sessionKey, `persona/${lastInjectedPersonaId}`);
-                lastInjectedPersonaId = null;
-                api.logger.info(`[omoc] Persona context cleared for ${sessionKey}`);
-            }
-            return;
-        }
-        if (lastInjectedPersonaId === personaId) {
+    // Use the typed hook system (api.on) for before_prompt_build.
+    // This directly injects into the system prompt via prependContext,
+    // which is more reliable than bootstrapFiles via agent:bootstrap.
+    //
+    // api.registerHook('before_prompt_build', ...) registers into the internal
+    // hook system which does NOT trigger before_prompt_build — only hookRunner
+    // (typed hooks via api.on) does.
+    api.on('before_prompt_build', (_event, ctx) => {
+        const result = resolveEffectivePersona(ctx);
+        if (!result) {
+            api.logger.info(`[omoc] Persona injector: no persona resolved (agentId=${ctx.agentId ?? 'none'}, manual=${getActivePersona() ?? 'none'})`);
             return;
         }
+        const { personaId, source } = result;
         try {
-            if (lastInjectedPersonaId) {
-                contextCollector.unregister(sessionKey, `persona/${lastInjectedPersonaId}`);
-            }
             const content = readPersonaPromptSync(personaId);
-            contextCollector.register(sessionKey, {
-                id: `persona/${personaId}`,
-                content,
-                priority: 'high',
-                source: 'persona',
-            });
-            personaSessionKeys.add(sessionKey);
-            lastInjectedPersonaId = personaId;
-            api.logger.info(`[omoc] Persona context registered: ${personaId}`);
+            api.logger.info(`[omoc] Persona injected via before_prompt_build: ${personaId} (${source}, agentId=${ctx.agentId ?? 'none'})`);
+            return {
+                prependContext: content,
+            };
         }
         catch (err) {
-            api.logger.error(`[omoc] Failed to register persona context ${personaId}:`, err);
+            api.logger.error(`[omoc] Failed to inject persona ${personaId}:`, err);
+            return;
         }
-    }, {
-        name: 'oh-my-openclaw.persona-injector',
-        description: 'Injects active persona prompt once per persona change',
-    });
+    }, { priority: 100 } // High priority — persona prompt should be prepended first
+    );
 }

package/dist/index.js

@@ -16,7 +16,17 @@ import { registerPersonaCommands } from './commands/persona-commands.js';
 import { registerPersonaInjector } from './hooks/persona-injector.js';
 import { registerContextInjector } from './hooks/context-injector.js';
 import { registerSetupCli } from './cli/setup.js';
-let initialized = false;
+/**
+ * Generation counter for multi-registration handling.
+ *
+ * OpenClaw may call register() multiple times with different api instances.
+ * Only the LAST call's api connects to the live hook dispatcher.
+ * We track a generation number so that hooks from stale registrations
+ * become no-ops, solving both:
+ *   - hooks not firing (stale api from early call)
+ *   - triple firing (all 3 registrations' hooks executing)
+ */
+let generation = 0;
 const registry = {
     hooks: [],
     services: [],
@@ -24,16 +34,30 @@ const registry = {
     commands: [],
     cli: [],
 };
+function guardedApi(api, gen) {
+    return {
+        ...api,
+        registerHook: (event, handler, meta) => {
+            api.registerHook(event, (evt) => {
+                if (gen !== generation)
+                    return evt;
+                return handler(evt);
+            }, meta);
+        },
+    };
+}
 export default function register(api) {
-    if (initialized) {
-        api.logger.warn(`[${PLUGIN_ID}] Plugin already initialized — skipping duplicate register() call`);
-        return;
-    }
-    initialized = true;
+    const gen = ++generation;
+    registry.hooks = [];
+    registry.services = [];
+    registry.tools = [];
+    registry.commands = [];
+    registry.cli = [];
     const config = getConfig(api);
-    api.logger.info(`[${PLUGIN_ID}] Initializing plugin v${VERSION}`);
+    api.logger.info(`[${PLUGIN_ID}] Initializing plugin v${VERSION} (register call #${gen})`);
+    const guarded = guardedApi(api, gen);
     try {
-        registerTodoEnforcer(api);
+        registerTodoEnforcer(guarded);
         registry.hooks.push('todo-enforcer');
         api.logger.info(`[${PLUGIN_ID}] Todo Enforcer hook registered (enabled: ${config.todo_enforcer_enabled})`);
     }
@@ -41,7 +65,7 @@ export default function register(api) {
         api.logger.error(`[${PLUGIN_ID}] Failed to register Todo Enforcer:`, err);
     }
     try {
-        registerCommentChecker(api);
+        registerCommentChecker(guarded);
         registry.hooks.push('comment-checker');
         api.logger.info(`[${PLUGIN_ID}] Comment Checker hook registered (enabled: ${config.comment_checker_enabled})`);
     }
@@ -49,7 +73,7 @@ export default function register(api) {
         api.logger.error(`[${PLUGIN_ID}] Failed to register Comment Checker:`, err);
     }
     try {
-        registerMessageMonitor(api);
+        registerMessageMonitor(guarded);
         registry.hooks.push('message-monitor', 'message-received-monitor');
         api.logger.info(`[${PLUGIN_ID}] Message Monitor hook registered`);
     }
@@ -57,7 +81,7 @@ export default function register(api) {
         api.logger.error(`[${PLUGIN_ID}] Failed to register Message Monitor:`, err);
     }
     try {
-        registerStartupHook(api);
+        registerStartupHook(guarded);
         registry.hooks.push('gateway-startup');
         api.logger.info(`[${PLUGIN_ID}] Gateway startup hook registered`);
     }
@@ -65,7 +89,7 @@ export default function register(api) {
         api.logger.error(`[${PLUGIN_ID}] Failed to register startup hook:`, err);
     }
     try {
-        registerPersonaInjector(api);
+        registerPersonaInjector(guarded);
         registry.hooks.push('persona-injector');
         api.logger.info(`[${PLUGIN_ID}] Persona injector hook registered`);
     }
@@ -73,7 +97,7 @@ export default function register(api) {
         api.logger.error(`[${PLUGIN_ID}] Failed to register Persona Injector:`, err);
     }
     try {
-        registerContextInjector(api);
+        registerContextInjector(guarded);
         registry.hooks.push('context-injector');
         api.logger.info(`[${PLUGIN_ID}] Context injector hook registered (before_prompt_build)`);
     }

package/dist/types.d.ts

@@ -122,4 +122,22 @@ export interface OmocPluginApi {
     }) => void | Promise<void>, opts?: {
         commands?: string[];
     }) => void;
+    on: <TEvent = unknown, TResult = unknown>(hookName: string, handler: (event: TEvent, ctx: TypedHookContext) => TResult | Promise<TResult> | void, opts?: {
+        priority?: number;
+    }) => void;
+}
+export interface TypedHookContext {
+    agentId?: string;
+    sessionKey?: string;
+    sessionId?: string;
+    workspaceDir?: string;
+    messageProvider?: unknown;
+}
+export interface BeforePromptBuildResult {
+    systemPrompt?: string;
+    prependContext?: string;
+}
+export interface BeforePromptBuildEvent {
+    prompt?: string;
+    messages?: unknown[];
 }

package/package.json

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