@happycastle/oh-my-openclaw 0.12.4 → 0.12.5

package/dist/commands/persona-commands.js

@@ -1,6 +1,5 @@
 import { getActivePersona, setActivePersona, resetPersonaState } from '../utils/persona-state.js';
 import { resolvePersonaId, listPersonas, DEFAULT_PERSONA_ID } from '../agents/persona-prompts.js';
-import { resetPersonaInjectorState } from '../hooks/persona-injector.js';
 function getDisplayName(personaId) {
     const persona = listPersonas().find((p) => p.id === personaId);
     return persona ? `${persona.emoji} ${persona.displayName}` : personaId;
@@ -16,7 +15,6 @@ export function registerPersonaCommands(api) {
             api.logger.info(`[omoc] Parsed args: "${args}" (length: ${args.length})`);
             if (!args) {
                 const previousId = getActivePersona();
-                resetPersonaInjectorState();
                 setActivePersona(DEFAULT_PERSONA_ID);
                 const name = getDisplayName(DEFAULT_PERSONA_ID);
                 const switchNote = previousId && previousId !== DEFAULT_PERSONA_ID
@@ -30,7 +28,6 @@ export function registerPersonaCommands(api) {
                 const wasActive = getActivePersona();
                 const wasName = wasActive ? getDisplayName(wasActive) : null;
                 resetPersonaState();
-                resetPersonaInjectorState();
                 return {
                     text: wasName
                         ? `# OmOC Mode: OFF\n\nPersona **${wasName}** deactivated. Applied immediately — your next message will use default behavior.`
@@ -67,7 +64,6 @@ export function registerPersonaCommands(api) {
                 };
             }
             const previousId = getActivePersona();
-            resetPersonaInjectorState();
             setActivePersona(resolvedId);
             const displayName = getDisplayName(resolvedId);
             const switched = listPersonas().find((p) => p.id === resolvedId);

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/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.4",
+  "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",