@happycastle/oh-my-openclaw 0.9.1 → 0.11.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,6 +1,7 @@
 import { OmocPluginApi } from '../types.js';
+export declare function resetPersonaContextEntries(): void;
 export declare function resetPersonaInjectorState(): void;
 export declare function getPersonaInjectorState(): {
-    lastPersonaInjectionTime: number;
+    lastInjectedPersonaId: string | null;
 };
 export declare function registerPersonaInjector(api: OmocPluginApi): void;

package/dist/hooks/persona-injector.js

@@ -1,47 +1,56 @@
 import { getActivePersona } from '../utils/persona-state.js';
 import { readPersonaPromptSync } from '../agents/persona-prompts.js';
-/** Minimum interval (ms) between persona injections to prevent regurgitation. */
-const PERSONA_INJECTION_COOLDOWN_MS = 5_000;
-let lastPersonaInjectionTime = 0;
+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() {
-    lastPersonaInjectionTime = 0;
+    lastInjectedPersonaId = null;
+    resetPersonaContextEntries();
 }
 export function getPersonaInjectorState() {
-    return { lastPersonaInjectionTime };
+    return { lastInjectedPersonaId };
 }
 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 alreadyInjected = event.context.bootstrapFiles.some((f) => f.path.startsWith('omoc://persona/'));
-        if (alreadyInjected) {
-            api.logger.info(`[omoc] Persona injection skipped (already present in bootstrapFiles)`);
-            return;
-        }
-        const now = Date.now();
-        if (now - lastPersonaInjectionTime < PERSONA_INJECTION_COOLDOWN_MS) {
-            api.logger.info(`[omoc] Persona injection skipped (cooldown)`);
+        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',
             });
-            lastPersonaInjectionTime = now;
-            api.logger.info(`[omoc] Persona injected: ${personaId}`);
+            personaSessionKeys.add(sessionKey);
+            lastInjectedPersonaId = 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',
-        description: 'Injects active persona prompt into agent bootstrap (with dedup + cooldown)',
+        description: 'Injects active persona prompt once per persona change',
     });
 }

package/dist/hooks/todo-enforcer.d.ts

@@ -1,8 +1,6 @@
 import { OmocPluginApi } from '../types.js';
+export type AgentRole = 'orchestrator' | 'worker' | 'lightweight';
+export declare function classifyAgentRole(agentId?: string): AgentRole;
 export declare function resetEnforcerState(): void;
-export declare function getEnforcerState(): {
-    lastInjectionTime: number;
-    consecutiveFailures: number;
-    disabledByFailures: boolean;
-};
+export declare function getEnforcerState(): {};
 export declare function registerTodoEnforcer(api: OmocPluginApi): void;

package/dist/hooks/todo-enforcer.js

@@ -1,28 +1,47 @@
 import { getConfig } from '../utils/config.js';
-const DIRECTIVE_TEXT = `[SYSTEM DIRECTIVE: OH-MY-OPENCLAW - TODO CONTINUATION]
-You MUST continue working on incomplete todos.
-- Do NOT stop until all tasks are marked complete
-- Do NOT ask for permission to continue
+import { contextCollector } from '../features/context-collector.js';
+const ORCHESTRATOR_IDS = new Set([
+    'omoc_prometheus',
+    'omoc_atlas',
+]);
+const WORKER_IDS = new Set([
+    'omoc_sisyphus',
+    'omoc_hephaestus',
+    'omoc_frontend',
+]);
+export function classifyAgentRole(agentId) {
+    if (!agentId)
+        return 'orchestrator';
+    if (ORCHESTRATOR_IDS.has(agentId))
+        return 'orchestrator';
+    if (WORKER_IDS.has(agentId))
+        return 'worker';
+    return 'lightweight';
+}
+const ORCHESTRATOR_DIRECTIVE = `[SYSTEM REMINDER - TODO CONTINUATION]
+If you have incomplete todos, continue working on them.
 - Mark each task complete immediately when finished
 - If blocked, document the blocker and move to next task
+- Do NOT restate prior messages — output only deltas and next concrete action
+- If no actionable next step remains, declare tasks complete and stop
 
-[SUBAGENT COMPLETION RULE]
-When you receive a subagent completion notification ("✅ Subagent finished"):
-- This is an ACTION TRIGGER, not an FYI
-- IMMEDIATELY check the subagent's result
-- Verify against success criteria
-- Then proceed to the next task/phase
-- NEVER stop after receiving a completion notification`;
-let lastInjectionTime = 0;
-let consecutiveFailures = 0;
-let disabledByFailures = false;
+When you receive a subagent completion notification:
+- Check the subagent's result against success criteria
+- Then proceed to the next task/phase`;
+const WORKER_DIRECTIVE = `[SYSTEM REMINDER - TASK COMPLETION]
+Complete your assigned task, return the result, then stop.
+- Do NOT restate prior messages — output only new findings or changes
+- If blocked, report the blocker and stop`;
+const DIRECTIVES = {
+    orchestrator: ORCHESTRATOR_DIRECTIVE,
+    worker: WORKER_DIRECTIVE,
+    lightweight: null,
+};
 export function resetEnforcerState() {
-    lastInjectionTime = 0;
-    consecutiveFailures = 0;
-    disabledByFailures = false;
+    // no-op — kept for API compatibility (no global state to reset)
 }
 export function getEnforcerState() {
-    return { lastInjectionTime, consecutiveFailures, disabledByFailures };
+    return {};
 }
 export function registerTodoEnforcer(api) {
     api.registerHook('agent:bootstrap', (event) => {
@@ -30,41 +49,26 @@ export function registerTodoEnforcer(api) {
         if (!config.todo_enforcer_enabled) {
             return;
         }
-        if (disabledByFailures) {
-            api.logger.warn('[omoc] Todo enforcer disabled due to consecutive failures');
-            return;
-        }
-        const now = Date.now();
-        if (config.todo_enforcer_cooldown_ms > 0 && (now - lastInjectionTime) < config.todo_enforcer_cooldown_ms) {
-            api.logger.info('[omoc] Todo enforcer skipped (cooldown)');
-            return;
-        }
-        if (!event.context.bootstrapFiles) {
-            event.context.bootstrapFiles = [];
-        }
-        const alreadyInjected = event.context.bootstrapFiles.some((f) => f.path === 'omoc://todo-enforcer');
-        if (alreadyInjected) {
-            api.logger.info('[omoc] Todo enforcer skipped (already present in bootstrapFiles)');
+        const role = classifyAgentRole(event.context.agentId);
+        const directive = DIRECTIVES[role];
+        const sessionKey = event.context.agentId || 'default';
+        if (!directive) {
             return;
         }
         try {
-            event.context.bootstrapFiles.push({
-                path: 'omoc://todo-enforcer',
-                content: DIRECTIVE_TEXT,
+            contextCollector.register(sessionKey, {
+                id: 'todo-enforcer',
+                content: directive,
+                priority: 'normal',
+                source: 'todo-enforcer',
             });
-            lastInjectionTime = now;
-            consecutiveFailures = 0;
-            api.logger.info('[omoc] Todo enforcer directive injected');
+            api.logger.info(`[omoc] Todo enforcer context registered (role: ${role})`);
         }
-        catch {
-            consecutiveFailures++;
-            if (config.todo_enforcer_max_failures > 0 && consecutiveFailures >= config.todo_enforcer_max_failures) {
-                disabledByFailures = true;
-                api.logger.error(`[omoc] Todo enforcer disabled after ${consecutiveFailures} consecutive failures`);
-            }
+        catch (err) {
+            api.logger.error('[omoc] Todo enforcer context registration failed:', err);
         }
     }, {
         name: 'oh-my-openclaw.todo-enforcer',
-        description: 'Injects TODO continuation directive into agent bootstrap',
+        description: 'Injects role-aware TODO directive into agent bootstrap',
     });
 }

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/package.json

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