@happycastle/oh-my-openclaw 0.19.0 → 0.20.1

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

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

package/dist/hooks/guardrail-injector.js

@@ -0,0 +1,37 @@
+import { LOG_PREFIX } from '../constants.js';
+const GUARDRAIL_RULES = `
+<anti-hallucination-guardrails>
+## Anti-Hallucination Rules (MANDATORY)
+
+These rules are NON-NEGOTIABLE. Violating them is a critical failure.
+
+### Rule 1: No Fake Tool Calls
+- If you say "I read the file", "I checked the code", "I confirmed in the source", or similar — there MUST be a corresponding \`read\`, \`exec\`, \`grep\`, or equivalent tool call in THE SAME turn.
+- If you did NOT make a tool call, you MUST say: "I haven't verified this directly — this is based on my prior knowledge/context."
+- Phrases that REQUIRE a preceding tool call: "확인했다", "읽었다", "봤다", "코드에서", "소스를 보면", "파일을 열어보니", "checked", "verified", "confirmed", "read the file", "looked at the code"
+
+### Rule 2: No Fabricated Results
+- Never invent file contents, command outputs, or API responses.
+- If you're unsure what a file contains, READ IT. Don't guess.
+- If a tool call fails, report the failure — don't make up what the result "would have been."
+
+### Rule 3: Distinguish Memory from Verification
+- Information from previous sessions or context = "이전 세션 기억 기반으로는..." or "Based on prior context..."
+- Information from THIS session's tool calls = state it directly
+- NEVER present memory/context as if you just verified it with a tool call.
+
+### Rule 4: Sub-agent Delegation Honesty
+- If asked to delegate to a sub-agent, you MUST actually call \`sessions_spawn\` or \`omoc_delegate\`.
+- Saying "서브에이전트 호출 완료" without a tool call = CRITICAL VIOLATION.
+- If the spawn fails, report the failure honestly.
+</anti-hallucination-guardrails>
+`.trim();
+export function registerGuardrailInjector(api) {
+    api.on('before_prompt_build', (_event, _ctx) => {
+        api.logger.info(`${LOG_PREFIX} Guardrail rules injected via before_prompt_build`);
+        return {
+            prependContext: GUARDRAIL_RULES,
+        };
+    }, { priority: 90 } // Between persona (100) and context-injector (50)
+    );
+}

package/dist/hooks/subagent-tracker.js

@@ -1,5 +1,5 @@
 import { LOG_PREFIX } from '../constants.js';
-import { trackSubagentSpawn, clearSubagentTracking, getCallerSessionKey } from '../services/webhook-bridge.js';
+import { trackSubagentSpawn, clearSubagentTracking, getCallerSessionKey, getTrackedSubagents } from '../services/webhook-bridge.js';
 import { callHooksWake } from '../utils/webhook-client.js';
 import { getConfig } from '../utils/config.js';
 const SPAWN_TOOL_NAME = 'sessions_spawn';
@@ -27,6 +27,43 @@ function extractSpawnResult(content) {
     }
     return null;
 }
+/**
+ * Tries to find a tracked sub-agent from the message content.
+ * Uses multiple strategies: runId match, childSessionKey match.
+ * Falls back to keyword detection for single-tracked-agent case
+ * only when multiple strong announce indicators are present.
+ */
+function findTrackedSubagentInContent(content) {
+    const tracked = getTrackedSubagents();
+    if (tracked.size === 0)
+        return null;
+    // Strategy 1: Direct runId match in content
+    const runIdMatch = content.match(/runId["\s:=]+["']?([a-zA-Z0-9_-]+)/);
+    if (runIdMatch && tracked.has(runIdMatch[1])) {
+        return runIdMatch[1];
+    }
+    // Strategy 2: childSessionKey match in content
+    for (const [runId, entry] of tracked) {
+        if (content.includes(entry.childSessionKey)) {
+            return runId;
+        }
+    }
+    // Strategy 3: Strong announce indicators (require at least 2)
+    // Only used for unambiguous single-tracked-agent case
+    if (tracked.size === 1) {
+        const strongIndicators = [
+            'Sub-agent', 'subagent', 'sub_agent',
+            'Result:', 'Summary:',
+        ];
+        const matchCount = strongIndicators.filter((kw) => content.includes(kw)).length;
+        // Require at least 2 strong indicators to avoid false positives
+        if (matchCount >= 2) {
+            const [onlyRunId] = tracked.keys();
+            return onlyRunId;
+        }
+    }
+    return null;
+}
 export function registerSubagentTracker(api) {
     api.registerHook('tool_result_persist', (payload) => {
         if (payload.tool !== SPAWN_TOOL_NAME)
@@ -34,7 +71,6 @@ export function registerSubagentTracker(api) {
         const content = typeof payload.content === 'string' ? payload.content : '';
         const spawnResult = extractSpawnResult(content);
         if (spawnResult) {
-            // Capture the caller's session key from the payload context
             const callerSessionKey = typeof payload.sessionId === 'string'
                 ? payload.sessionId
                 : undefined;
@@ -50,34 +86,63 @@ export function registerSubagentTracker(api) {
         name: 'oh-my-openclaw.subagent-tracker',
         description: 'Tracks sessions_spawn results for stale sub-agent detection',
     });
+    api.on('subagent_ended', async (event, ctx) => {
+        const runId = typeof event?.runId === 'string' ? event.runId : undefined;
+        if (!runId)
+            return;
+        const tracked = getTrackedSubagents();
+        const wasTracked = tracked.has(runId);
+        const callerSession = getCallerSessionKey(runId);
+        clearSubagentTracking(runId);
+        if (!wasTracked)
+            return;
+        api.logger.info(`${LOG_PREFIX} subagent_ended received: runId=${runId} (callerSession=${callerSession ?? 'unknown'})`);
+        const config = getConfig(api);
+        if (config.webhook_bridge_enabled && config.gateway_url && config.hooks_token) {
+            const requesterSessionKey = typeof ctx?.requesterSessionKey === 'string'
+                ? (ctx.requesterSessionKey)
+                : undefined;
+            const wakeMessage = requesterSessionKey
+                ? `[System] Sub-agent completed (runId=${runId}, requester=${requesterSessionKey}). Process the result and continue pending work.`
+                : `[System] Sub-agent completed (runId=${runId}). Process the result and continue pending work.`;
+            const result = await callHooksWake(wakeMessage, { gateway_url: config.gateway_url, hooks_token: config.hooks_token }, api.logger);
+            if (result.ok) {
+                api.logger.info(`${LOG_PREFIX} Wake sent from subagent_ended: runId=${runId}`);
+            }
+            else {
+                api.logger.warn(`${LOG_PREFIX} Wake from subagent_ended failed: ${result.error ?? `status ${result.status}`}`);
+            }
+        }
+    }, { priority: 120 });
     api.registerHook('message:received', (context) => {
         const content = context?.content ?? '';
-        if (!content.includes('Sub-agent') && !content.includes('subagent') && !content.includes('announce')) {
+        // Skip empty/short messages
+        if (content.length < 10)
             return undefined;
-        }
-        const runIdMatch = content.match(/runId["\s:=]+["']?([a-zA-Z0-9_-]+)/);
-        if (runIdMatch) {
-            // Get caller session key before clearing tracking
-            const callerSession = getCallerSessionKey(runIdMatch[1]);
-            clearSubagentTracking(runIdMatch[1]);
-            api.logger.info(`${LOG_PREFIX} Cleared sub-agent tracking: runId=${runIdMatch[1]} (announce received, callerSession=${callerSession ?? 'unknown'})`);
-            // Send wake to ensure the main agent processes the announce and continues work
-            const config = getConfig(api);
-            if (config.webhook_bridge_enabled && config.gateway_url && config.hooks_token) {
-                void callHooksWake(`[System] Sub-agent completed (runId=${runIdMatch[1]}). Process the announce result and continue any pending work.`, { gateway_url: config.gateway_url, hooks_token: config.hooks_token }, api.logger).then((result) => {
-                    if (result.ok) {
-                        api.logger.info(`${LOG_PREFIX} Wake sent after sub-agent announce: runId=${runIdMatch[1]}`);
-                    }
-                    else {
-                        api.logger.warn(`${LOG_PREFIX} Wake after announce failed: ${result.error ?? `status ${result.status}`}`);
-                    }
-                });
-            }
+        // Try to find a tracked sub-agent in this message
+        const matchedRunId = findTrackedSubagentInContent(content);
+        if (!matchedRunId)
+            return undefined;
+        // Found a match — this is likely a sub-agent announce
+        const callerSession = getCallerSessionKey(matchedRunId);
+        clearSubagentTracking(matchedRunId);
+        api.logger.info(`${LOG_PREFIX} Sub-agent announce detected: runId=${matchedRunId} (callerSession=${callerSession ?? 'unknown'})`);
+        // Send wake to ensure the main agent processes the announce and continues work
+        const config = getConfig(api);
+        if (config.webhook_bridge_enabled && config.gateway_url && config.hooks_token) {
+            void callHooksWake(`[System] Sub-agent completed (runId=${matchedRunId}). Process the announce result and continue any pending work.`, { gateway_url: config.gateway_url, hooks_token: config.hooks_token }, api.logger).then((result) => {
+                if (result.ok) {
+                    api.logger.info(`${LOG_PREFIX} Wake sent after sub-agent announce: runId=${matchedRunId}`);
+                }
+                else {
+                    api.logger.warn(`${LOG_PREFIX} Wake after announce failed: ${result.error ?? `status ${result.status}`}`);
+                }
+            });
         }
         return undefined;
     }, {
         name: 'oh-my-openclaw.subagent-announce-detector',
-        description: 'Detects sub-agent announce messages, clears stale tracking, and wakes main agent',
+        description: 'Detects sub-agent announce messages via multi-strategy matching, clears stale tracking, and wakes main agent',
     });
 }
 export { extractSpawnResult };

package/dist/index.js

@@ -18,6 +18,7 @@ import { registerRalphCommands } from './commands/ralph-commands.js';
 import { registerStatusCommands } from './commands/status-commands.js';
 import { registerPersonaCommands } from './commands/persona-commands.js';
 import { registerContextInjector } from './hooks/context-injector.js';
+import { registerGuardrailInjector } from './hooks/guardrail-injector.js';
 import { registerSessionSync } from './hooks/session-sync.js';
 import { registerSpawnGuard } from './hooks/spawn-guard.js';
 import { registerKeywordDetector } from './hooks/keyword-detector/hook.js';
@@ -95,6 +96,11 @@ export default function register(api) {
         registry.hooks.push('context-injector');
         api.logger.info(`[${PLUGIN_ID}] Context injector hook registered (before_prompt_build)`);
     });
+    safeRegister(api, 'guardrail-injector', 'hook', () => {
+        registerGuardrailInjector(guarded);
+        registry.hooks.push('guardrail-injector');
+        api.logger.info(`[${PLUGIN_ID}] Guardrail injector hook registered (before_prompt_build, priority 90)`);
+    });
     safeRegister(api, 'session-sync', 'hook', () => {
         registerSessionSync(api);
         registry.hooks.push('session-sync');

package/dist/tools/task-delegation.js

@@ -34,7 +34,7 @@ const DelegateParamsSchema = Type.Object({
     skills: Type.Optional(Type.Array(Type.String(), { description: 'Skill names to load' })),
     background: Type.Optional(Type.Boolean({ description: 'Run in background (default: false)', default: false })),
 });
-function getModelForCategory(category, api) {
+function getRecommendedModelForCategory(category, api) {
     const config = getConfig(api);
     const override = config.model_routing?.[category];
     if (override?.model) {
@@ -59,7 +59,7 @@ export function registerDelegateTool(api) {
                 return toolError(`Invalid category: ${params.category}. Valid: ${validCategories.join(', ')}`);
             }
             const category = params.category;
-            const { model, alternatives } = getModelForCategory(category, api);
+            const { model, alternatives } = getRecommendedModelForCategory(category, api);
             const agentId = params.agent_id || DEFAULT_CATEGORY_AGENTS[category];
             api.logger.info(`${LOG_PREFIX} Delegating task:`, { category, model, agentId });
             const instruction = [
@@ -68,12 +68,12 @@ export function registerDelegateTool(api) {
                 '⚡ NOW CALL sessions_spawn with these parameters:',
                 `  task: "${params.task_description}"`,
                 `  mode: "run"`,
-                `  model: "${model}"`,
                 `  agentId: "${agentId}"`,
-                alternatives?.length ? `  fallback_models: ${JSON.stringify(alternatives)}` : '',
-                alternatives?.length ? `  If "${model}" is unavailable, try: ${alternatives.join(', ')}` : '',
+                `  # recommended model (do NOT pass to sessions_spawn): ${model}`,
+                alternatives?.length ? `  Recommended fallback models (informational only): ${alternatives.join(', ')}` : '',
                 params.background ? '  (background execution — results will arrive via push notification)' : '',
                 '',
+                'Do NOT set sessions_spawn model unless explicitly asked by user.',
                 'Do NOT just return this metadata. Actually call sessions_spawn NOW.',
                 '',
                 '⚠️ AFTER the subagent completes:',

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "oh-my-openclaw",
   "name": "Oh-My-OpenClaw",
   "description": "Multi-agent orchestration plugin — 11 agents, category-based model routing, todo enforcer, ralph loop, agent setup CLI, and custom tools",
-  "version": "0.19.0",
+  "version": "0.20.1",
   "skills": [
     "skills"
   ],

package/package.json

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