@happycastle/oh-my-openclaw 0.13.4 → 0.14.0

package/dist/commands/persona-commands.js

@@ -1,6 +1,6 @@
 import { LOG_PREFIX } from '../constants.js';
-import { getActivePersona, setActivePersonaId, resetPersonaState } from '../utils/persona-state.js';
-import { resolvePersonaId, listPersonas, DEFAULT_PERSONA_ID } from '../agents/persona-prompts.js';
+import { getActivePersona, setActivePersonaId, resetPersonaState, replaceAgentsMd, restoreAgentsMdToDefault } from '../utils/persona-state.js';
+import { resolvePersonaId, listPersonas, readPersonaPrompt, DEFAULT_PERSONA_ID } from '../agents/persona-prompts.js';
 function getDisplayName(personaId) {
     const persona = listPersonas().find((p) => p.id === personaId);
     return persona ? `${persona.emoji} ${persona.displayName}` : personaId;
@@ -17,22 +17,25 @@ export function registerPersonaCommands(api) {
             if (!args) {
                 const previousId = await getActivePersona();
                 await setActivePersonaId(DEFAULT_PERSONA_ID);
+                const content = await readPersonaPrompt(DEFAULT_PERSONA_ID);
+                await replaceAgentsMd(content);
                 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}**${switchNote}\n\nApplied immediately — your next message will use this persona.\n\nUse \`/omoc list\` to see available personas, or \`/omoc <name>\` to switch.`,
+                    text: `# OmOC Mode: ON\n\nActive persona: **${name}**${switchNote}\n\nAGENTS.md replaced with persona prompt. 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 = await getActivePersona();
                 const wasName = wasActive ? getDisplayName(wasActive) : null;
                 await resetPersonaState();
+                await restoreAgentsMdToDefault();
                 return {
                     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.',
+                        ? `# OmOC Mode: OFF\n\nPersona **${wasName}** deactivated. AGENTS.md restored to default.`
+                        : '# OmOC Mode: OFF\n\nNo persona was active. AGENTS.md restored to default.',
                 };
             }
             if (args === 'list') {
@@ -66,13 +69,15 @@ export function registerPersonaCommands(api) {
             }
             const previousId = await getActivePersona();
             await setActivePersonaId(resolvedId);
+            const content = await readPersonaPrompt(resolvedId);
+            await replaceAgentsMd(content);
             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}**${switchNote}\n\nApplied immediately — your next message will use the ${switched?.theme ?? 'persona'} prompt.`,
+                text: `# Persona Switched\n\nActive persona: **${displayName}**${switchNote}\n\nAGENTS.md replaced. Your next message will use the ${switched?.theme ?? 'persona'} prompt.`,
             };
         },
     });

package/dist/hooks/session-sync.d.ts

@@ -0,0 +1,3 @@
+import { OmocPluginApi } from '../types.js';
+/** session_start hook: re-sync AGENTS.md from `.omoc-state` (source of truth). */
+export declare function registerSessionSync(api: OmocPluginApi): void;

package/dist/hooks/session-sync.js

@@ -0,0 +1,33 @@
+import { LOG_PREFIX } from '../constants.js';
+import { getActivePersona, resolveAgentsMdPath, replaceAgentsMd } from '../utils/persona-state.js';
+import { readPersonaPromptSync } from '../agents/persona-prompts.js';
+import { readFileSync } from 'fs';
+/** session_start hook: re-sync AGENTS.md from `.omoc-state` (source of truth). */
+export function registerSessionSync(api) {
+    api.on('session_start', async (_event, _ctx) => {
+        try {
+            const activePersona = await getActivePersona();
+            if (!activePersona)
+                return;
+            const personaContent = readPersonaPromptSync(activePersona);
+            if (personaContent.startsWith('[OmOC]')) {
+                api.logger.warn(`${LOG_PREFIX} Session sync: persona file issue for ${activePersona}`);
+                return;
+            }
+            const agentsPath = resolveAgentsMdPath();
+            try {
+                const current = readFileSync(agentsPath, 'utf-8');
+                if (current.includes(personaContent.slice(0, 100)))
+                    return;
+            }
+            catch {
+                // AGENTS.md missing or unreadable — needs sync
+            }
+            await replaceAgentsMd(personaContent);
+            api.logger.info(`${LOG_PREFIX} Session sync: AGENTS.md re-synced with .omoc-state (persona=${activePersona})`);
+        }
+        catch (err) {
+            api.logger.error(`${LOG_PREFIX} Session sync failed:`, err);
+        }
+    }, { priority: 200 });
+}

package/dist/hooks/spawn-guard.d.ts

@@ -0,0 +1,3 @@
+import { OmocPluginApi } from '../types.js';
+/** before_tool_call hook: block sessions_spawn without agentId when OmOC persona is active. */
+export declare function registerSpawnGuard(api: OmocPluginApi): void;

package/dist/hooks/spawn-guard.js

@@ -0,0 +1,33 @@
+import { LOG_PREFIX } from '../constants.js';
+import { getActivePersona } from '../utils/persona-state.js';
+import { ALL_AGENT_IDS } from '../agents/agent-ids.js';
+const SPAWN_TOOL_NAME = 'sessions_spawn';
+const AVAILABLE_AGENTS = ALL_AGENT_IDS.map((id) => id.replace('omoc_', '')).join(', ');
+/** before_tool_call hook: block sessions_spawn without agentId when OmOC persona is active. */
+export function registerSpawnGuard(api) {
+    api.on('before_tool_call', async (event, _ctx) => {
+        if (event.toolName !== SPAWN_TOOL_NAME) {
+            return;
+        }
+        let activePersona;
+        try {
+            activePersona = await getActivePersona();
+        }
+        catch {
+            return;
+        }
+        if (!activePersona)
+            return;
+        const agentId = event.params.agentId;
+        if (typeof agentId === 'string' && agentId.trim().length > 0)
+            return;
+        api.logger.info(`${LOG_PREFIX} Spawn guard: blocked sessions_spawn without agentId (active persona=${activePersona})`);
+        return {
+            block: true,
+            blockReason: `[OmOC] Sub-agent spawn BLOCKED: agentId is required when OmOC persona is active (current: ${activePersona}). ` +
+                `You MUST provide the agentId parameter in your sessions_spawn call. ` +
+                `Available agents: ${AVAILABLE_AGENTS}. ` +
+                `Retry with agentId set to the appropriate agent for this task.`,
+        };
+    }, { priority: 150 });
+}

package/dist/index.js

@@ -14,8 +14,9 @@ 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 { registerContextInjector } from './hooks/context-injector.js';
+import { registerSessionSync } from './hooks/session-sync.js';
+import { registerSpawnGuard } from './hooks/spawn-guard.js';
 import { registerSetupCli } from './cli/setup.js';
 /**
  * Generation counter for multi-registration handling.
@@ -77,16 +78,21 @@ export default function register(api) {
         registry.hooks.push('gateway-startup');
         api.logger.info(`[${PLUGIN_ID}] Gateway startup hook registered`);
     });
-    safeRegister(api, 'persona-injector', 'hook', () => {
-        registerPersonaInjector(guarded);
-        registry.hooks.push('persona-injector');
-        api.logger.info(`[${PLUGIN_ID}] Persona injector hook registered`);
-    });
     safeRegister(api, 'context-injector', 'hook', () => {
         registerContextInjector(guarded);
         registry.hooks.push('context-injector');
         api.logger.info(`[${PLUGIN_ID}] Context injector hook registered (before_prompt_build)`);
     });
+    safeRegister(api, 'session-sync', 'hook', () => {
+        registerSessionSync(api);
+        registry.hooks.push('session-sync');
+        api.logger.info(`[${PLUGIN_ID}] Session sync hook registered (session_start)`);
+    });
+    safeRegister(api, 'spawn-guard', 'hook', () => {
+        registerSpawnGuard(api);
+        registry.hooks.push('spawn-guard');
+        api.logger.info(`[${PLUGIN_ID}] Spawn guard hook registered (before_tool_call)`);
+    });
     safeRegister(api, 'ralph-loop', 'service', () => {
         registerRalphLoop(api);
         registry.services.push('ralph-loop');

package/dist/types.d.ts

@@ -118,4 +118,5 @@ export interface BeforePromptBuildResult {
 export interface BeforePromptBuildEvent {
     prompt?: string;
     messages?: unknown[];
+    systemPrompt?: string;
 }

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

@@ -4,3 +4,6 @@ export declare function setActivePersonaId(id: string | null): Promise<void>;
 export declare function setActivePersona(id: string | null): Promise<void>;
 export declare function getActivePersona(): Promise<string | null>;
 export declare function resetPersonaState(): Promise<void>;
+export declare function resolveAgentsMdPath(): string;
+export declare function replaceAgentsMd(personaContent: string): Promise<void>;
+export declare function restoreAgentsMdToDefault(): Promise<void>;

package/dist/utils/persona-state.js

@@ -1,8 +1,10 @@
 import { readFile, writeFile, mkdir } from 'fs/promises';
 import { dirname, join } from 'path';
+import { homedir } from 'os';
 let activePersonaId = null;
 let loaded = false;
-let stateFilePath = join('workspace', '.omoc-state', 'active-persona');
+const stateDir = join('workspace', '.omoc-state');
+let stateFilePath = join(stateDir, 'active-persona');
 export async function initPersonaState(_api) {
     try {
         await mkdir(dirname(stateFilePath), { recursive: true });
@@ -50,7 +52,67 @@ async function saveToDisk() {
         await writeFile(stateFilePath, activePersonaId ?? '', 'utf-8');
     }
     catch (error) {
-        // silent fail — in-memory state still works, but log for debugging
         console.warn('[omoc] Failed to persist persona state to disk:', error);
     }
 }
+export function resolveAgentsMdPath() {
+    const profile = process.env.OPENCLAW_PROFILE?.trim();
+    const wsDir = (profile && profile.toLowerCase() !== 'default')
+        ? join(homedir(), '.openclaw', `workspace-${profile}`)
+        : join(homedir(), '.openclaw', 'workspace');
+    return join(wsDir, 'AGENTS.md');
+}
+export async function replaceAgentsMd(personaContent) {
+    const agentsPath = resolveAgentsMdPath();
+    await mkdir(dirname(agentsPath), { recursive: true });
+    const merged = `${DEFAULT_AGENTS_MD}\n---\n\n${personaContent}`;
+    await writeFile(agentsPath, merged, 'utf-8');
+}
+export async function restoreAgentsMdToDefault() {
+    const agentsPath = resolveAgentsMdPath();
+    await mkdir(dirname(agentsPath), { recursive: true });
+    await writeFile(agentsPath, DEFAULT_AGENTS_MD, 'utf-8');
+}
+const DEFAULT_AGENTS_MD = `# AGENTS.md - Your Workspace
+
+This folder is home. Treat it that way.
+
+## First Run
+
+If \`BOOTSTRAP.md\` exists, that's your birth certificate. Follow it, figure out who you are, then delete it. You won't need it again.
+
+## Every Session
+
+Before doing anything else:
+
+1. Read \`SOUL.md\` — this is who you are
+2. Read \`USER.md\` — this is who you're helping
+3. Read \`memory/YYYY-MM-DD.md\` (today + yesterday) for recent context
+4. **If in MAIN SESSION** (direct chat with your human): Also read \`MEMORY.md\`
+
+Don't ask permission. Just do it.
+
+## Memory
+
+You wake up fresh each session. These files are your continuity:
+
+- **Daily notes:** \`memory/YYYY-MM-DD.md\` (create \`memory/\` if needed) — raw logs of what happened
+- **Long-term:** \`MEMORY.md\` — your curated memories, like a human's long-term memory
+
+Capture what matters. Decisions, context, things to remember. Skip the secrets unless asked to keep them.
+
+## Safety
+
+- Don't exfiltrate private data. Ever.
+- Don't run destructive commands without asking.
+- \`trash\` > \`rm\` (recoverable beats gone forever)
+- When in doubt, ask.
+
+## Tools
+
+Skills provide your tools. When you need one, check its \`SKILL.md\`. Keep local notes in \`TOOLS.md\`.
+
+## Make It Yours
+
+This is a starting point. Add your own conventions, style, and rules as you figure out what works.
+`;

package/package.json

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

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

@@ -1,10 +0,0 @@
-import { OmocPluginApi } from '../types.js';
-/**
- * Check whether persona content is already present in session history.
- *
- * OpenClaw's `prependContext` is merged into the user prompt and persisted
- * in session history. Without this check the persona text accumulates —
- * appearing once per historical user message sent to the model.
- */
-export declare function isPersonaAlreadyInHistory(messages: unknown[] | undefined, personaContent: string): boolean;
-export declare function registerPersonaInjector(api: OmocPluginApi): void;

package/dist/hooks/persona-injector.js

@@ -1,87 +0,0 @@
-import { LOG_PREFIX } from '../constants.js';
-import { getActivePersona } from '../utils/persona-state.js';
-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
- */
-async function resolveEffectivePersona(ctx) {
-    const manual = await getActivePersona();
-    if (manual) {
-        const resolved = resolvePersonaId(manual);
-        if (resolved)
-            return { personaId: resolved, source: 'manual' };
-    }
-    const agentId = ctx.agentId;
-    if (!agentId)
-        return null;
-    const resolved = resolvePersonaId(agentId);
-    if (!resolved)
-        return null;
-    return { personaId: resolved, source: 'auto' };
-}
-const FINGERPRINT_LENGTH = 200;
-/**
- * Check whether persona content is already present in session history.
- *
- * OpenClaw's `prependContext` is merged into the user prompt and persisted
- * in session history. Without this check the persona text accumulates —
- * appearing once per historical user message sent to the model.
- */
-export function isPersonaAlreadyInHistory(messages, personaContent) {
-    if (!messages || messages.length === 0)
-        return false;
-    const fingerprint = personaContent.slice(0, FINGERPRINT_LENGTH).trim();
-    if (!fingerprint)
-        return false;
-    for (const msg of messages) {
-        if (!msg || typeof msg !== 'object')
-            continue;
-        const record = msg;
-        if (record['role'] !== 'user')
-            continue;
-        const content = record['content'];
-        if (typeof content === 'string' && content.includes(fingerprint)) {
-            return true;
-        }
-    }
-    return false;
-}
-export function registerPersonaInjector(api) {
-    // 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', async (event, ctx) => {
-        const result = await resolveEffectivePersona(ctx);
-        if (!result) {
-            const manual = await getActivePersona();
-            api.logger.info(`${LOG_PREFIX} Persona injector: no persona resolved (agentId=${ctx.agentId ?? 'none'}, manual=${manual ?? 'none'})`);
-            return;
-        }
-        const { personaId, source } = result;
-        try {
-            const content = readPersonaPromptSync(personaId);
-            if (isPersonaAlreadyInHistory(event.messages, content)) {
-                api.logger.info(`${LOG_PREFIX} Persona already in history, skipping injection: ${personaId} (${source})`);
-                return;
-            }
-            api.logger.info(`${LOG_PREFIX} Persona injected via before_prompt_build: ${personaId} (${source}, agentId=${ctx.agentId ?? 'none'})`);
-            return {
-                prependContext: content,
-            };
-        }
-        catch (err) {
-            api.logger.error(`${LOG_PREFIX} Failed to inject persona ${personaId}:`, err);
-            return;
-        }
-    }, { priority: 100 } // High priority — persona prompt should be prepended first
-    );
-}