@happycastle/oh-my-openclaw 0.10.0 → 0.12.0

package/dist/features/context-collector.d.ts

@@ -0,0 +1,30 @@
+export type ContextPriority = 'critical' | 'high' | 'normal' | 'low';
+export type ContextSourceType = 'persona' | 'todo-enforcer' | 'system' | 'plugin';
+export interface ContextEntry {
+    id: string;
+    content: string;
+    priority: ContextPriority;
+    source: ContextSourceType;
+    oneShot?: boolean;
+}
+export interface RegisterContextOptions {
+    id: string;
+    content: string;
+    priority?: ContextPriority;
+    source?: ContextSourceType;
+    oneShot?: boolean;
+}
+export declare class ContextCollector {
+    private sessions;
+    register(sessionKey: string, options: RegisterContextOptions): void;
+    unregister(sessionKey: string, entryId: string): void;
+    collect(sessionKey: string): ContextEntry[];
+    collectAsString(sessionKey: string, separator?: string): string;
+    clear(sessionKey: string): void;
+    clearAll(): void;
+    getEntries(sessionKey: string): ContextEntry[];
+    hasEntries(sessionKey: string): boolean;
+    private getOrCreateSession;
+    private sortEntries;
+}
+export declare const contextCollector: ContextCollector;

package/dist/features/context-collector.js

@@ -0,0 +1,85 @@
+const PRIORITY_ORDER = {
+    critical: 0,
+    high: 1,
+    normal: 2,
+    low: 3,
+};
+export class ContextCollector {
+    sessions = new Map();
+    register(sessionKey, options) {
+        const sessionEntries = this.getOrCreateSession(sessionKey);
+        const entry = {
+            id: options.id,
+            content: options.content,
+            priority: options.priority ?? 'normal',
+            source: options.source ?? 'plugin',
+            oneShot: options.oneShot ?? false,
+        };
+        sessionEntries.set(options.id, entry);
+    }
+    unregister(sessionKey, entryId) {
+        const sessionEntries = this.sessions.get(sessionKey);
+        if (!sessionEntries) {
+            return;
+        }
+        sessionEntries.delete(entryId);
+        if (sessionEntries.size === 0) {
+            this.sessions.delete(sessionKey);
+        }
+    }
+    collect(sessionKey) {
+        const sessionEntries = this.sessions.get(sessionKey);
+        if (!sessionEntries) {
+            return [];
+        }
+        const entries = this.sortEntries([...sessionEntries.values()]);
+        for (const entry of entries) {
+            if (entry.oneShot) {
+                sessionEntries.delete(entry.id);
+            }
+        }
+        if (sessionEntries.size === 0) {
+            this.sessions.delete(sessionKey);
+        }
+        return entries;
+    }
+    collectAsString(sessionKey, separator = '\n\n') {
+        const entries = this.collect(sessionKey);
+        return entries.map((entry) => entry.content).join(separator);
+    }
+    clear(sessionKey) {
+        this.sessions.delete(sessionKey);
+    }
+    clearAll() {
+        this.sessions.clear();
+    }
+    getEntries(sessionKey) {
+        const sessionEntries = this.sessions.get(sessionKey);
+        if (!sessionEntries) {
+            return [];
+        }
+        return this.sortEntries([...sessionEntries.values()]);
+    }
+    hasEntries(sessionKey) {
+        const sessionEntries = this.sessions.get(sessionKey);
+        return Boolean(sessionEntries && sessionEntries.size > 0);
+    }
+    getOrCreateSession(sessionKey) {
+        let sessionEntries = this.sessions.get(sessionKey);
+        if (!sessionEntries) {
+            sessionEntries = new Map();
+            this.sessions.set(sessionKey, sessionEntries);
+        }
+        return sessionEntries;
+    }
+    sortEntries(entries) {
+        return entries.sort((a, b) => {
+            const priorityDiff = PRIORITY_ORDER[a.priority] - PRIORITY_ORDER[b.priority];
+            if (priorityDiff !== 0) {
+                return priorityDiff;
+            }
+            return a.id.localeCompare(b.id);
+        });
+    }
+}
+export const contextCollector = new ContextCollector();

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

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

package/dist/hooks/context-injector.js

@@ -0,0 +1,20 @@
+import { contextCollector } from '../features/context-collector.js';
+export function registerContextInjector(api) {
+    api.registerHook('before_prompt_build', (event) => {
+        const sessionKey = event.agentId || 'default';
+        if (!contextCollector.hasEntries(sessionKey)) {
+            return event;
+        }
+        const entryCount = contextCollector.getEntries(sessionKey).length;
+        const collectedContext = contextCollector.collectAsString(sessionKey);
+        if (!collectedContext) {
+            return event;
+        }
+        event.prependContext = 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',
+    });
+}

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

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

package/dist/hooks/persona-injector.js

@@ -1,8 +1,22 @@
 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);
+            }
+        }
+    }
+    personaSessionKeys.clear();
+}
 export function resetPersonaInjectorState() {
     lastInjectedPersonaId = null;
+    resetPersonaContextEntries();
 }
 export function getPersonaInjectorState() {
     return { lastInjectedPersonaId };
@@ -10,30 +24,30 @@ export function getPersonaInjectorState() {
 export function registerPersonaInjector(api) {
     api.registerHook('agent:bootstrap', (event) => {
         const personaId = getActivePersona();
+        const sessionKey = event.context.agentId || 'default';
         if (!personaId) {
             return;
         }
-        if (!event.context.bootstrapFiles) {
-            event.context.bootstrapFiles = [];
-        }
-        const alreadyInFiles = event.context.bootstrapFiles.some((f) => f.path.startsWith('omoc://persona/'));
-        if (alreadyInFiles) {
-            return;
-        }
         if (lastInjectedPersonaId === personaId) {
             return;
         }
         try {
+            if (lastInjectedPersonaId) {
+                contextCollector.unregister(sessionKey, `persona/${lastInjectedPersonaId}`);
+            }
             const content = readPersonaPromptSync(personaId);
-            event.context.bootstrapFiles.push({
-                path: `omoc://persona/${personaId}`,
+            contextCollector.register(sessionKey, {
+                id: `persona/${personaId}`,
                 content,
+                priority: 'high',
+                source: 'persona',
             });
+            personaSessionKeys.add(sessionKey);
             lastInjectedPersonaId = personaId;
-            api.logger.info(`[omoc] Persona injected: ${personaId}`);
+            api.logger.info(`[omoc] Persona context registered: ${personaId}`);
         }
         catch (err) {
-            api.logger.error(`[omoc] Failed to inject persona ${personaId}:`, err);
+            api.logger.error(`[omoc] Failed to register persona context ${personaId}:`, err);
         }
     }, {
         name: 'oh-my-openclaw.persona-injector',

package/dist/hooks/todo-enforcer.js

@@ -1,4 +1,5 @@
 import { getConfig } from '../utils/config.js';
+import { contextCollector } from '../features/context-collector.js';
 const ORCHESTRATOR_IDS = new Set([
     'omoc_prometheus',
     'omoc_atlas',
@@ -50,25 +51,21 @@ export function registerTodoEnforcer(api) {
         }
         const role = classifyAgentRole(event.context.agentId);
         const directive = DIRECTIVES[role];
+        const sessionKey = event.context.agentId || 'default';
         if (!directive) {
             return;
         }
-        if (!event.context.bootstrapFiles) {
-            event.context.bootstrapFiles = [];
-        }
-        const alreadyInjected = event.context.bootstrapFiles.some((f) => f.path === 'omoc://todo-enforcer');
-        if (alreadyInjected) {
-            return;
-        }
         try {
-            event.context.bootstrapFiles.push({
-                path: 'omoc://todo-enforcer',
+            contextCollector.register(sessionKey, {
+                id: 'todo-enforcer',
                 content: directive,
+                priority: 'normal',
+                source: 'todo-enforcer',
             });
-            api.logger.info(`[omoc] Todo enforcer injected (role: ${role})`);
+            api.logger.info(`[omoc] Todo enforcer context registered (role: ${role})`);
         }
         catch (err) {
-            api.logger.error('[omoc] Todo enforcer injection failed:', err);
+            api.logger.error('[omoc] Todo enforcer context registration failed:', err);
         }
     }, {
         name: 'oh-my-openclaw.todo-enforcer',

package/dist/index.js

@@ -14,6 +14,7 @@ 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 { registerContextInjector } from './hooks/context-injector.js';
 import { registerSetupCli } from './cli/setup.js';
 const registry = {
     hooks: [],
@@ -65,6 +66,14 @@ export default function register(api) {
     catch (err) {
         api.logger.error(`[${PLUGIN_ID}] Failed to register Persona Injector:`, err);
     }
+    try {
+        registerContextInjector(api);
+        registry.hooks.push('context-injector');
+        api.logger.info(`[${PLUGIN_ID}] Context injector hook registered (before_prompt_build)`);
+    }
+    catch (err) {
+        api.logger.error(`[${PLUGIN_ID}] Failed to register Context Injector:`, err);
+    }
     try {
         registerRalphLoop(api);
         registry.services.push('ralph-loop');

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

@@ -1,3 +1,5 @@
+export declare function initPersonaState(filePath?: string): void;
 export declare function setActivePersona(id: string | null): void;
 export declare function getActivePersona(): string | null;
 export declare function resetPersonaState(): void;
+export declare function resetPersonaStateForTesting(): void;

package/dist/utils/persona-state.js

@@ -1,10 +1,48 @@
+import { readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { dirname, join } from 'path';
 let activePersonaId = null;
+let loaded = false;
+let stateFilePath = join('workspace', '.omoc-state', 'active-persona');
+export function initPersonaState(filePath) {
+    if (filePath)
+        stateFilePath = filePath;
+    loadFromDisk();
+}
 export function setActivePersona(id) {
     activePersonaId = id;
+    loaded = true;
+    saveToDisk();
 }
 export function getActivePersona() {
+    if (!loaded)
+        loadFromDisk();
     return activePersonaId;
 }
 export function resetPersonaState() {
     activePersonaId = null;
+    loaded = true;
+    saveToDisk();
+}
+export function resetPersonaStateForTesting() {
+    activePersonaId = null;
+    loaded = true;
+}
+function loadFromDisk() {
+    try {
+        const content = readFileSync(stateFilePath, 'utf-8').trim();
+        activePersonaId = content || null;
+    }
+    catch {
+        activePersonaId = null;
+    }
+    loaded = true;
+}
+function saveToDisk() {
+    try {
+        mkdirSync(dirname(stateFilePath), { recursive: true });
+        writeFileSync(stateFilePath, activePersonaId ?? '', 'utf-8');
+    }
+    catch {
+        // silent fail — in-memory state still works
+    }
 }

package/package.json

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