@happycastle/oh-my-openclaw 0.3.1 → 0.5.0

package/dist/cli.js

@@ -56,6 +56,7 @@ function commandExists(cmd) {
     }
 }
 function run(cmd, opts) {
+    const throwOnError = opts?.throwOnError ?? false;
     try {
         return execSync(cmd, {
             cwd: opts?.cwd,
@@ -64,8 +65,11 @@ function run(cmd, opts) {
         })?.toString().trim() ?? '';
     }
     catch (e) {
-        const err = e;
-        return err.stdout?.toString().trim() ?? '';
+        if (!throwOnError) {
+            const err = e;
+            return err.stdout?.toString().trim() ?? '';
+        }
+        throw e;
     }
 }
 function isSymlink(p) {
@@ -145,10 +149,17 @@ function install(installDir) {
     const pluginDir = join(installDir, 'plugin');
     if (existsSync(join(pluginDir, 'package.json'))) {
         info('Installing dependencies...');
-        run('npm install', { cwd: pluginDir });
+        run('npm install', { cwd: pluginDir, throwOnError: true });
         ok('Dependencies installed');
         info('Building TypeScript...');
-        run('npm run build', { cwd: pluginDir });
+        try {
+            run('npm run build', { cwd: pluginDir, throwOnError: true });
+        }
+        catch (e) {
+            const message = e instanceof Error ? e.message : String(e);
+            fail(`Plugin build failed: ${message}`);
+            process.exit(1);
+        }
         ok('Plugin built');
         // Run tests silently to verify
         info('Running tests...');

package/dist/commands/status-commands.d.ts

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

package/dist/commands/status-commands.js

@@ -0,0 +1,45 @@
+import { PLUGIN_ID } from '../types.js';
+import { VERSION } from '../version.js';
+import { getConfig } from '../utils/config.js';
+import { getStatus as getRalphStatus } from '../services/ralph-loop.js';
+import { getMessageCount } from '../hooks/message-monitor.js';
+export function registerStatusCommands(api) {
+    api.registerCommand({
+        name: 'omoc-health',
+        description: 'Plugin health check (auto-reply, no AI invocation)',
+        handler: async () => {
+            const config = getConfig(api);
+            const ralphState = await getRalphStatus();
+            const messageCount = getMessageCount();
+            return {
+                text: [
+                    `# ${PLUGIN_ID} Health`,
+                    `- Version: ${VERSION}`,
+                    `- Ralph Loop: ${ralphState.active ? 'ACTIVE' : 'INACTIVE'}`,
+                    `- Todo Enforcer: ${config.todo_enforcer_enabled ? 'ON' : 'OFF'}`,
+                    `- Comment Checker: ${config.comment_checker_enabled ? 'ON' : 'OFF'}`,
+                    `- Messages Tracked: ${messageCount}`,
+                ].join('\n'),
+            };
+        },
+    });
+    api.registerCommand({
+        name: 'omoc-config',
+        description: 'Show current plugin configuration (auto-reply)',
+        handler: () => {
+            const config = getConfig(api);
+            const safeConfig = {};
+            for (const [key, value] of Object.entries(config)) {
+                if (typeof value === 'string' && (key.includes('token') || key.includes('secret') || key.includes('key'))) {
+                    safeConfig[key] = '***';
+                }
+                else {
+                    safeConfig[key] = value;
+                }
+            }
+            return {
+                text: `# ${PLUGIN_ID} Configuration\n\`\`\`json\n${JSON.stringify(safeConfig, null, 2)}\n\`\`\``,
+            };
+        },
+    });
+}

package/dist/commands/workflow-commands.js

@@ -1,14 +1,14 @@
-import { readFileSync } from 'fs';
+import { promises as fs } from 'fs';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 // From dist/commands/ → plugin root is ../../
 const PLUGIN_ROOT = join(__dirname, '..', '..');
-function readWorkflow(workflowName) {
+async function readWorkflow(workflowName) {
     try {
         const workflowPath = join(PLUGIN_ROOT, 'workflows', `${workflowName}.md`);
-        return readFileSync(workflowPath, 'utf-8');
+        return await fs.readFile(workflowPath, 'utf-8');
     }
     catch {
         return `Error: Could not read workflow file 'workflows/${workflowName}.md'. Plugin root: ${PLUGIN_ROOT}`;
@@ -18,9 +18,9 @@ export function registerWorkflowCommands(api) {
     api.registerCommand({
         name: 'ultrawork',
         description: 'Full planning \u2192 execution \u2192 verification workflow',
-        handler: (ctx) => {
+        handler: async (ctx) => {
             const taskDescription = ctx.args || 'No task specified';
-            const workflow = readWorkflow('ultrawork');
+            const workflow = await readWorkflow('ultrawork');
             return {
                 text: `# Ultrawork Mode\n\n**Task**: ${taskDescription}\n\n---\n\n${workflow}`,
             };
@@ -29,9 +29,9 @@ export function registerWorkflowCommands(api) {
     api.registerCommand({
         name: 'plan',
         description: 'Create a structured execution plan',
-        handler: (ctx) => {
+        handler: async (ctx) => {
             const topic = ctx.args || 'No topic specified';
-            const workflow = readWorkflow('plan');
+            const workflow = await readWorkflow('plan');
             return {
                 text: `# Planning Mode\n\n**Topic**: ${topic}\n\n---\n\n${workflow}`,
             };
@@ -40,9 +40,9 @@ export function registerWorkflowCommands(api) {
     api.registerCommand({
         name: 'start-work',
         description: 'Execute an approved plan',
-        handler: (ctx) => {
+        handler: async (ctx) => {
             const planPath = ctx.args || 'most recent plan';
-            const workflow = readWorkflow('start-work');
+            const workflow = await readWorkflow('start-work');
             return {
                 text: `# Start Work Mode\n\n**Plan**: ${planPath}\n\n---\n\n${workflow}`,
             };

package/dist/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const CATEGORIES: readonly ["quick", "deep", "ultrabrain", "visual-engineering", "multimodal", "artistry", "unspecified-low", "unspecified-high", "writing"];
+export type Category = (typeof CATEGORIES)[number];

package/dist/constants.js

@@ -0,0 +1,11 @@
+export const CATEGORIES = [
+    'quick',
+    'deep',
+    'ultrabrain',
+    'visual-engineering',
+    'multimodal',
+    'artistry',
+    'unspecified-low',
+    'unspecified-high',
+    'writing',
+];

package/dist/hooks/message-monitor.d.ts

@@ -8,4 +8,4 @@ export declare function registerMessageMonitor(api: OmocPluginApi): void;
  * Returns the current message count
  * Useful for status reporting
  */
-export declare function getMessageCount(): number;
+export declare function getMessageCount(channelId?: string): number;

package/dist/hooks/message-monitor.js

@@ -1,5 +1,4 @@
-// Module-level state for tracking messages
-let messageCount = 0;
+const messageCounts = new Map();
 /**
  * Registers the message monitor hook
  * Logs message events for audit purposes without modifying messages
@@ -11,26 +10,44 @@ export function registerMessageMonitor(api) {
         const preview = content.substring(0, 100);
         const channelId = context?.channelId || 'unknown';
         const timestamp = new Date().toISOString();
+        const currentCount = messageCounts.get(channelId) ?? 0;
+        const nextCount = currentCount + 1;
+        messageCounts.set(channelId, nextCount);
         // Log the message event
         api.logger.info('[omoc] Message sent:', {
             preview,
             channelId,
             timestamp,
-            messageCount: messageCount + 1
+            messageCount: nextCount
         });
-        // Increment message counter
-        messageCount++;
         // Return undefined to not modify the message
         return undefined;
     }, {
         name: 'oh-my-openclaw.message-monitor',
         description: 'Monitors message events for audit logging'
     });
+    api.registerHook('message:received', (context) => {
+        const content = context?.content || '';
+        const preview = content.substring(0, 100);
+        const channelId = context?.channelId || 'unknown';
+        api.logger.info('[omoc] Message received:', { preview, channelId });
+        return undefined;
+    }, {
+        name: 'oh-my-openclaw.message-received-monitor',
+        description: 'Monitors inbound message events for audit logging'
+    });
 }
 /**
  * Returns the current message count
  * Useful for status reporting
  */
-export function getMessageCount() {
-    return messageCount;
+export function getMessageCount(channelId) {
+    if (channelId) {
+        return messageCounts.get(channelId) ?? 0;
+    }
+    let total = 0;
+    for (const count of messageCounts.values()) {
+        total += count;
+    }
+    return total;
 }

package/dist/hooks/startup.d.ts

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

package/dist/hooks/startup.js

@@ -0,0 +1,11 @@
+import { PLUGIN_ID } from '../types.js';
+import { VERSION } from '../version.js';
+export function registerStartupHook(api) {
+    api.registerHook('gateway:startup', () => {
+        api.logger.info(`[${PLUGIN_ID}] Gateway started — plugin v${VERSION} active`);
+        return undefined;
+    }, {
+        name: 'oh-my-openclaw.gateway-startup',
+        description: 'Logs plugin activation on gateway startup'
+    });
+}

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

@@ -1,2 +1,8 @@
 import { OmocPluginApi } from '../types.js';
+export declare function resetEnforcerState(): void;
+export declare function getEnforcerState(): {
+    lastInjectionTime: number;
+    consecutiveFailures: number;
+    disabledByFailures: boolean;
+};
 export declare function registerTodoEnforcer(api: OmocPluginApi): void;

package/dist/hooks/todo-enforcer.js

@@ -5,20 +5,51 @@ You MUST continue working on incomplete todos.
 - Do NOT ask for permission to continue
 - Mark each task complete immediately when finished
 - If blocked, document the blocker and move to next task`;
+let lastInjectionTime = 0;
+let consecutiveFailures = 0;
+let disabledByFailures = false;
+export function resetEnforcerState() {
+    lastInjectionTime = 0;
+    consecutiveFailures = 0;
+    disabledByFailures = false;
+}
+export function getEnforcerState() {
+    return { lastInjectionTime, consecutiveFailures, disabledByFailures };
+}
 export function registerTodoEnforcer(api) {
     api.registerHook('agent:bootstrap', (event) => {
         const config = getConfig(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 = [];
         }
-        event.context.bootstrapFiles.push({
-            path: 'omoc://todo-enforcer',
-            content: DIRECTIVE_TEXT,
-        });
-        api.logger.info('[omoc] Todo enforcer directive injected');
+        try {
+            event.context.bootstrapFiles.push({
+                path: 'omoc://todo-enforcer',
+                content: DIRECTIVE_TEXT,
+            });
+            lastInjectionTime = now;
+            consecutiveFailures = 0;
+            api.logger.info('[omoc] Todo enforcer directive injected');
+        }
+        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`);
+            }
+        }
     }, {
         name: 'oh-my-openclaw.todo-enforcer',
         description: 'Injects TODO continuation directive into agent bootstrap',

package/dist/index.js

@@ -1,19 +1,30 @@
 import { PLUGIN_ID } from './types.js';
+import { VERSION } from './version.js';
 import { getConfig } from './utils/config.js';
 import { registerTodoEnforcer } from './hooks/todo-enforcer.js';
 import { registerCommentChecker } from './hooks/comment-checker.js';
 import { registerMessageMonitor } from './hooks/message-monitor.js';
+import { registerStartupHook } from './hooks/startup.js';
 import { registerRalphLoop } from './services/ralph-loop.js';
 import { registerDelegateTool } from './tools/task-delegation.js';
 import { registerLookAtTool } from './tools/look-at.js';
 import { registerCheckpointTool } from './tools/checkpoint.js';
 import { registerWorkflowCommands } from './commands/workflow-commands.js';
 import { registerRalphCommands } from './commands/ralph-commands.js';
+import { registerStatusCommands } from './commands/status-commands.js';
+/** Registry of successfully registered components */
+const registry = {
+    hooks: [],
+    services: [],
+    tools: [],
+    commands: [],
+};
 export default function register(api) {
     const config = getConfig(api);
-    api.logger.info(`[${PLUGIN_ID}] Initializing plugin v0.3.1`);
+    api.logger.info(`[${PLUGIN_ID}] Initializing plugin v${VERSION}`);
     try {
         registerTodoEnforcer(api);
+        registry.hooks.push('todo-enforcer');
         api.logger.info(`[${PLUGIN_ID}] Todo Enforcer hook registered (enabled: ${config.todo_enforcer_enabled})`);
     }
     catch (err) {
@@ -21,6 +32,7 @@ export default function register(api) {
     }
     try {
         registerCommentChecker(api);
+        registry.hooks.push('comment-checker');
         api.logger.info(`[${PLUGIN_ID}] Comment Checker hook registered (enabled: ${config.comment_checker_enabled})`);
     }
     catch (err) {
@@ -28,13 +40,23 @@ export default function register(api) {
     }
     try {
         registerMessageMonitor(api);
+        registry.hooks.push('message-monitor', 'message-received-monitor');
         api.logger.info(`[${PLUGIN_ID}] Message Monitor hook registered`);
     }
     catch (err) {
         api.logger.error(`[${PLUGIN_ID}] Failed to register Message Monitor:`, err);
     }
+    try {
+        registerStartupHook(api);
+        registry.hooks.push('gateway-startup');
+        api.logger.info(`[${PLUGIN_ID}] Gateway startup hook registered`);
+    }
+    catch (err) {
+        api.logger.error(`[${PLUGIN_ID}] Failed to register startup hook:`, err);
+    }
     try {
         registerRalphLoop(api);
+        registry.services.push('ralph-loop');
         api.logger.info(`[${PLUGIN_ID}] Ralph Loop service registered`);
     }
     catch (err) {
@@ -42,6 +64,7 @@ export default function register(api) {
     }
     try {
         registerDelegateTool(api);
+        registry.tools.push('omoc_delegate');
         api.logger.info(`[${PLUGIN_ID}] Delegate tool registered`);
     }
     catch (err) {
@@ -49,6 +72,7 @@ export default function register(api) {
     }
     try {
         registerLookAtTool(api);
+        registry.tools.push('omoc_look_at');
         api.logger.info(`[${PLUGIN_ID}] Look-At tool registered`);
     }
     catch (err) {
@@ -56,6 +80,7 @@ export default function register(api) {
     }
     try {
         registerCheckpointTool(api);
+        registry.tools.push('omoc_checkpoint');
         api.logger.info(`[${PLUGIN_ID}] Checkpoint tool registered`);
     }
     catch (err) {
@@ -63,6 +88,7 @@ export default function register(api) {
     }
     try {
         registerWorkflowCommands(api);
+        registry.commands.push('ultrawork', 'plan', 'start-work');
         api.logger.info(`[${PLUGIN_ID}] Workflow commands registered (ultrawork, plan, start-work)`);
     }
     catch (err) {
@@ -70,20 +96,29 @@ export default function register(api) {
     }
     try {
         registerRalphCommands(api);
+        registry.commands.push('ralph-loop', 'ralph-stop', 'omoc-status');
         api.logger.info(`[${PLUGIN_ID}] Ralph commands registered (ralph-loop, ralph-stop, omoc-status)`);
     }
     catch (err) {
         api.logger.error(`[${PLUGIN_ID}] Failed to register Ralph commands:`, err);
     }
+    try {
+        registerStatusCommands(api);
+        registry.commands.push('omoc-health', 'omoc-config');
+        api.logger.info(`[${PLUGIN_ID}] Status commands registered (omoc-health, omoc-config)`);
+    }
+    catch (err) {
+        api.logger.error(`[${PLUGIN_ID}] Failed to register Status commands:`, err);
+    }
     api.registerGatewayMethod('oh-my-openclaw.status', () => {
         return {
             ok: true,
             plugin: PLUGIN_ID,
-            version: '0.3.1',
-            hooks: ['todo-enforcer', 'comment-checker', 'message-monitor'],
-            services: ['ralph-loop'],
-            tools: ['omoc_delegate', 'omoc_look_at', 'omoc_checkpoint'],
-            commands: ['ultrawork', 'plan', 'start-work', 'ralph-loop', 'ralph-stop', 'omoc-status'],
+            version: VERSION,
+            hooks: [...registry.hooks],
+            services: [...registry.services],
+            tools: [...registry.tools],
+            commands: [...registry.commands],
             config: {
                 todo_enforcer_enabled: config.todo_enforcer_enabled,
                 comment_checker_enabled: config.comment_checker_enabled,

package/dist/services/ralph-loop.js

@@ -1,4 +1,3 @@
-import { promises as fs } from 'fs';
 import { getConfig } from '../utils/config.js';
 import { join } from 'path';
 import { ABSOLUTE_MAX_RALPH_ITERATIONS, PLUGIN_ID, } from '../types.js';
@@ -25,23 +24,15 @@ async function loadStateFromFile() {
         currentState = { ...DEFAULT_STATE };
         return;
     }
-    const loadedState = await readState(stateFilePath);
-    if (loadedState) {
-        currentState = loadedState;
+    const result = await readState(stateFilePath);
+    if (result.ok) {
+        currentState = result.data;
         return;
     }
-    let hasExistingFile = false;
-    try {
-        await fs.access(stateFilePath);
-        hasExistingFile = true;
-    }
-    catch {
-        hasExistingFile = false;
-    }
-    currentState = { ...DEFAULT_STATE };
-    if (hasExistingFile) {
+    if (result.error === 'corrupted') {
         getApi().logger.warn(`[${PLUGIN_ID}] Ralph Loop state was corrupted; recovering with default state`);
     }
+    currentState = { ...DEFAULT_STATE };
 }
 async function saveStateToFile() {
     if (!stateFilePath) {

package/dist/tools/checkpoint.js

@@ -3,37 +3,39 @@ import { promises as fs } from 'fs';
 import { join } from 'path';
 import { readState, writeState, ensureDir } from '../utils/state.js';
 import { getConfig } from '../utils/config.js';
+const CheckpointParamsSchema = Type.Object({
+    action: Type.Union([
+        Type.Literal('save'),
+        Type.Literal('load'),
+        Type.Literal('list'),
+    ], { description: 'Checkpoint operation' }),
+    task: Type.Optional(Type.String({ description: 'Current task name (for save)' })),
+    step: Type.Optional(Type.String({ description: 'Current step name (for save)' })),
+    changed_files: Type.Optional(Type.Array(Type.String(), { description: 'Files modified since last checkpoint' })),
+    next_action: Type.Optional(Type.String({ description: 'What to do after restore' })),
+});
 export function registerCheckpointTool(api) {
     api.registerTool({
         name: 'omoc_checkpoint',
         description: 'Save, load, or list session checkpoints for crash recovery',
-        parameters: Type.Object({
-            action: Type.Unsafe({
-                type: 'string',
-                enum: ['save', 'load', 'list'],
-                description: 'Checkpoint operation',
-            }),
-            task: Type.Optional(Type.String({ description: 'Current task name (for save)' })),
-            step: Type.Optional(Type.String({ description: 'Current step name (for save)' })),
-            changed_files: Type.Optional(Type.Array(Type.String(), { description: 'Files modified since last checkpoint' })),
-            next_action: Type.Optional(Type.String({ description: 'What to do after restore' })),
-        }),
+        parameters: CheckpointParamsSchema,
         execute: async (params) => {
             const config = getConfig(api);
             const checkpointDir = config.checkpoint_dir;
             await ensureDir(checkpointDir);
             if (params.action === 'save') {
+                const now = Date.now();
                 const checkpoint = {
                     type: 'session-checkpoint',
-                    session_id: `checkpoint-${Date.now()}`,
+                    session_id: `checkpoint-${now}`,
                     task: params.task || 'unknown',
                     step: params.step || 'unknown',
                     changed_files: params.changed_files || [],
                     verification: { diagnostics: 'not-run', tests: 'not-run', build: 'not-run' },
                     next_action: params.next_action || '',
-                    timestamp: new Date().toISOString(),
+                    timestamp: new Date(now).toISOString(),
                 };
-                const filename = `checkpoint-${Date.now()}.json`;
+                const filename = `checkpoint-${now}.json`;
                 await writeState(join(checkpointDir, filename), checkpoint);
                 return {
                     content: [
@@ -54,17 +56,17 @@ export function registerCheckpointTool(api) {
                         };
                     }
                     const mostRecent = jsonFiles[0];
-                    const checkpoint = await readState(join(checkpointDir, mostRecent));
-                    if (!checkpoint) {
+                    const result = await readState(join(checkpointDir, mostRecent));
+                    if (!result.ok) {
                         return {
-                            content: [{ type: 'text', text: `Failed to load checkpoint: ${mostRecent}` }],
+                            content: [{ type: 'text', text: `Failed to load checkpoint ${mostRecent}: ${result.message}` }],
                         };
                     }
                     return {
                         content: [
                             {
                                 type: 'text',
-                                text: JSON.stringify({ loaded: mostRecent, checkpoint }, null, 2),
+                                text: JSON.stringify({ loaded: mostRecent, checkpoint: result.data }, null, 2),
                             },
                         ],
                     };
@@ -90,12 +92,12 @@ export function registerCheckpointTool(api) {
                         };
                     }
                     const checkpoints = await Promise.all(jsonFiles.map(async (file) => {
-                        const checkpoint = await readState(join(checkpointDir, file));
+                        const result = await readState(join(checkpointDir, file));
                         return {
                             file,
-                            timestamp: checkpoint?.timestamp || 'unknown',
-                            task: checkpoint?.task || 'unknown',
-                            step: checkpoint?.step || 'unknown',
+                            timestamp: result.ok ? result.data.timestamp : 'unknown',
+                            task: result.ok ? result.data.task : 'unknown',
+                            step: result.ok ? result.data.step : 'unknown',
                         };
                     }));
                     return {

package/dist/tools/look-at.js

@@ -1,10 +1,12 @@
 import { Type } from '@sinclair/typebox';
 import { execSync } from 'child_process';
+import { randomUUID } from 'crypto';
 import { promises as fs } from 'fs';
 import { TOOL_PREFIX } from '../types.js';
-const TMUX_SOCKET = '/tmp/openclaw-tmux-sockets/openclaw.sock';
+import { getConfig } from '../utils/config.js';
 const TMUX_SESSION_TARGET = 'gemini:0.0';
 const GEMINI_TIMEOUT_MS = 60_000;
+let isRunning = false;
 function escapeShellArg(arg) {
     return arg.replace(/'/g, "'\\''");
 }
@@ -21,14 +23,19 @@ export function registerLookAtTool(api) {
             })),
         }),
         execute: async (params) => {
-            const tempFile = `/tmp/omoc-look-at-${Date.now()}.md`;
+            if (isRunning) {
+                return { content: [{ type: 'text', text: 'Error: Another look_at operation is in progress' }] };
+            }
+            isRunning = true;
+            const tempFile = `/tmp/omoc-look-at-${randomUUID()}.md`;
+            const tmuxSocket = getConfig(api).tmux_socket;
             try {
                 const model = params.model ?? 'gemini-2.5-flash';
                 const escapedFilePath = escapeShellArg(params.file_path);
                 const escapedGoal = escapeShellArg(params.goal);
                 const escapedModel = escapeShellArg(model);
                 const command = `gemini -m ${escapedModel} --prompt '${escapedGoal}' -f '${escapedFilePath}' -o text > ${tempFile} 2>&1`;
-                const tmuxCommand = `tmux -S ${TMUX_SOCKET} send-keys -t ${TMUX_SESSION_TARGET} -l -- '${command}' && sleep 0.1 && tmux -S ${TMUX_SOCKET} send-keys -t ${TMUX_SESSION_TARGET} Enter`;
+                const tmuxCommand = `tmux -S ${tmuxSocket} send-keys -t ${TMUX_SESSION_TARGET} -l -- '${command}' && sleep 0.1 && tmux -S ${tmuxSocket} send-keys -t ${TMUX_SESSION_TARGET} Enter`;
                 execSync(tmuxCommand, { timeout: 5000 });
                 const startTime = Date.now();
                 while (Date.now() - startTime < GEMINI_TIMEOUT_MS) {
@@ -40,13 +47,17 @@ export function registerLookAtTool(api) {
                             return { content: [{ type: 'text', text: result }] };
                         }
                     }
-                    catch { }
+                    catch {
+                        /* file not ready yet, continue polling */
+                    }
                     await new Promise((resolve) => setTimeout(resolve, 2000));
                 }
                 try {
                     await fs.unlink(tempFile);
                 }
-                catch { }
+                catch (cleanupErr) {
+                    api.logger.warn('[omoc] Failed to clean up temp file:', tempFile, cleanupErr);
+                }
                 return {
                     content: [
                         { type: 'text', text: 'Error: Gemini CLI timed out after 60 seconds' },
@@ -57,10 +68,15 @@ export function registerLookAtTool(api) {
                 try {
                     await fs.unlink(tempFile);
                 }
-                catch { }
+                catch (cleanupErr) {
+                    api.logger.warn('[omoc] Failed to clean up temp file:', tempFile, cleanupErr);
+                }
                 const message = error instanceof Error ? error.message : String(error);
                 return { content: [{ type: 'text', text: `Error: ${message}` }] };
             }
+            finally {
+                isRunning = false;
+            }
         },
         optional: true,
     });