@happycastle/oh-my-openclaw 0.1.0

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

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

package/dist/commands/ralph-commands.js

@@ -0,0 +1,62 @@
+import { startLoop, stopLoop, getStatus } from '../services/ralph-loop.js';
+import { getMessageCount } from '../hooks/message-monitor.js';
+import { getConfig } from '../utils/config.js';
+export function registerRalphCommands(api) {
+    // /ralph-loop command
+    api.registerCommand({
+        name: 'ralph-loop',
+        description: 'Start the Ralph Loop self-completion mechanism',
+        handler: async (ctx) => {
+            const args = (ctx.args || '').trim().split(/\s+/).filter(Boolean);
+            const config = getConfig(api);
+            const maxIterations = args[0] ? parseInt(args[0], 10) : config.max_ralph_iterations;
+            const taskFile = args[1] || '';
+            if (isNaN(maxIterations) || maxIterations < 1) {
+                return { text: 'Error: First argument must be a positive number (max iterations)' };
+            }
+            const result = await startLoop(taskFile, maxIterations);
+            return {
+                text: result.success
+                    ? `✅ Ralph Loop started\n- Max iterations: ${result.state.maxIterations}\n- Task file: ${result.state.taskFile || 'none'}\n- Started: ${result.state.startedAt}`
+                    : `❌ ${result.message}`,
+            };
+        },
+    });
+    // /ralph-stop command
+    api.registerCommand({
+        name: 'ralph-stop',
+        description: 'Stop the active Ralph Loop',
+        handler: async () => {
+            const result = await stopLoop();
+            return {
+                text: `Ralph Loop stopped\n- Final iteration: ${result.state.iteration}/${result.state.maxIterations}\n- Was active: ${result.state.active}`,
+            };
+        },
+    });
+    // /omoc-status command
+    api.registerCommand({
+        name: 'omoc-status',
+        description: 'Show Oh-My-OpenClaw plugin status',
+        handler: async () => {
+            const config = getConfig(api);
+            const ralphState = await getStatus();
+            const messageCount = getMessageCount();
+            const lines = [
+                '# Oh-My-OpenClaw Status',
+                '',
+                `## Ralph Loop: ${ralphState.active ? 'ACTIVE' : 'INACTIVE'}`,
+                ralphState.active ? `  Iteration: ${ralphState.iteration}/${ralphState.maxIterations}` : '',
+                ralphState.active ? `  Task: ${ralphState.taskFile || 'none'}` : '',
+                ralphState.active ? `  Started: ${ralphState.startedAt}` : '',
+                '',
+                `## Todo Enforcer: ${config.todo_enforcer_enabled ? 'ENABLED' : 'DISABLED'}`,
+                `  Cooldown: ${config.todo_enforcer_cooldown_ms}ms`,
+                '',
+                `## Comment Checker: ${config.comment_checker_enabled ? 'ENABLED' : 'DISABLED'}`,
+                '',
+                `## Messages Monitored: ${messageCount}`,
+            ].filter((l) => l !== '');
+            return { text: lines.join('\n') };
+        },
+    });
+}

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

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

package/dist/commands/workflow-commands.js

@@ -0,0 +1,46 @@
+import { readFileSync } from 'fs';
+import { join } from 'path';
+function readWorkflow(workflowName) {
+    try {
+        const workflowPath = join(process.cwd(), 'workflows', `${workflowName}.md`);
+        return readFileSync(workflowPath, 'utf-8');
+    }
+    catch {
+        return `Error: Could not read workflow file 'workflows/${workflowName}.md'. Make sure the oh-my-openclaw skill directory is accessible.`;
+    }
+}
+export function registerWorkflowCommands(api) {
+    api.registerCommand({
+        name: 'ultrawork',
+        description: 'Full planning \u2192 execution \u2192 verification workflow',
+        handler: (ctx) => {
+            const taskDescription = ctx.args || 'No task specified';
+            const workflow = readWorkflow('ultrawork');
+            return {
+                text: `# Ultrawork Mode\n\n**Task**: ${taskDescription}\n\n---\n\n${workflow}`,
+            };
+        },
+    });
+    api.registerCommand({
+        name: 'plan',
+        description: 'Create a structured execution plan',
+        handler: (ctx) => {
+            const topic = ctx.args || 'No topic specified';
+            const workflow = readWorkflow('plan');
+            return {
+                text: `# Planning Mode\n\n**Topic**: ${topic}\n\n---\n\n${workflow}`,
+            };
+        },
+    });
+    api.registerCommand({
+        name: 'start-work',
+        description: 'Execute an approved plan',
+        handler: (ctx) => {
+            const planPath = ctx.args || 'most recent plan';
+            const workflow = readWorkflow('start-work');
+            return {
+                text: `# Start Work Mode\n\n**Plan**: ${planPath}\n\n---\n\n${workflow}`,
+            };
+        },
+    });
+}

package/dist/hooks/comment-checker.d.ts

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

package/dist/hooks/comment-checker.js

@@ -0,0 +1,86 @@
+import { getConfig } from '../utils/config.js';
+const NON_CODE_EXTENSIONS = ['.md', '.json', '.yaml', '.yml', '.txt'];
+const AI_SLOP_PATTERNS = [
+    /^\s*\/\/\s*Import\s/i,
+    /^\s*\/\/\s*Define\s/i,
+    /^\s*\/\/\s*Return\s/i,
+    /^\s*\/\/\s*Export\s/i,
+    /^\s*\/\/\s*Set\s.*\sto\s/i,
+    /^\s*\/\/\s*Loop\s/i,
+    /^\s*\/\/\s*Initialize\s/i,
+    /^\s*\/\/\s*Create\s(a|an|the|new)\s/i,
+    /^\s*\/\/\s*This\s(function|method|class|module|component)\s/i,
+    /^\s*\/\/\s*Handle\s(the|an?)?\s?(error|exception|response|request|event)/i,
+    /^\s*\/\/\s*Check\s(if|whether)\s/i,
+];
+function hasNonCodeExtension(value) {
+    const lowered = value.toLowerCase();
+    return NON_CODE_EXTENSIONS.some((ext) => lowered.endsWith(ext));
+}
+function extractFileHint(payload) {
+    if (typeof payload.file === 'string') {
+        return payload.file;
+    }
+    if (typeof payload.filename === 'string') {
+        return payload.filename;
+    }
+    if (typeof payload.path === 'string') {
+        return payload.path;
+    }
+    return 'unknown';
+}
+function contentLooksNonCode(content) {
+    const extensionMatch = content.match(/\b[^\s"']+\.(md|json|ya?ml|txt)\b/i);
+    return extensionMatch !== null;
+}
+function findViolations(content, file) {
+    const violations = [];
+    const lines = content.split(/\r?\n/);
+    for (let index = 0; index < lines.length; index += 1) {
+        const lineText = lines[index];
+        const isViolation = AI_SLOP_PATTERNS.some((pattern) => pattern.test(lineText));
+        if (isViolation) {
+            violations.push({
+                file,
+                line: index + 1,
+                content: lineText.trim(),
+                reason: 'AI slop: obvious/narrating comment',
+            });
+        }
+    }
+    return violations;
+}
+function appendViolationSummary(content, violations) {
+    const details = violations
+        .map((violation) => `  - Line ${violation.line}: "${violation.content}" → ${violation.reason}`)
+        .join('\n');
+    return `${content}\n\n---\n⚠️ [OMOC Comment Checker] Found ${violations.length} AI slop comment(s):\n${details}\n\nConsider removing these obvious/narrating comments to keep code clean.`;
+}
+export function registerCommentChecker(api) {
+    api.registerHook('tool_result_persist', (payload) => {
+        const config = getConfig(api);
+        if (!config.comment_checker_enabled) {
+            return undefined;
+        }
+        const { content } = payload;
+        if (typeof content !== 'string' || content.trim().length === 0) {
+            return undefined;
+        }
+        const fileHint = extractFileHint(payload);
+        if (hasNonCodeExtension(fileHint) || contentLooksNonCode(content)) {
+            return undefined;
+        }
+        const violations = findViolations(content, fileHint);
+        if (violations.length === 0) {
+            return undefined;
+        }
+        const updatedContent = appendViolationSummary(content, violations);
+        return {
+            ...payload,
+            content: updatedContent,
+        };
+    }, {
+        name: 'oh-my-openclaw.comment-checker',
+        description: 'Detects AI slop comments in code',
+    });
+}

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

@@ -0,0 +1,11 @@
+import { OmocPluginApi } from '../types.js';
+/**
+ * Registers the message monitor hook
+ * Logs message events for audit purposes without modifying messages
+ */
+export declare function registerMessageMonitor(api: OmocPluginApi): void;
+/**
+ * Returns the current message count
+ * Useful for status reporting
+ */
+export declare function getMessageCount(): number;

package/dist/hooks/message-monitor.js

@@ -0,0 +1,36 @@
+// Module-level state for tracking messages
+let messageCount = 0;
+/**
+ * Registers the message monitor hook
+ * Logs message events for audit purposes without modifying messages
+ */
+export function registerMessageMonitor(api) {
+    api.registerHook('message:sent', (context) => {
+        // Extract relevant info from event context
+        const content = context?.content || '';
+        const preview = content.substring(0, 100);
+        const channelId = context?.channelId || 'unknown';
+        const timestamp = new Date().toISOString();
+        // Log the message event
+        api.logger.info('[omoc] Message sent:', {
+            preview,
+            channelId,
+            timestamp,
+            messageCount: messageCount + 1
+        });
+        // 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'
+    });
+}
+/**
+ * Returns the current message count
+ * Useful for status reporting
+ */
+export function getMessageCount() {
+    return messageCount;
+}

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

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

package/dist/hooks/todo-enforcer.js

@@ -0,0 +1,26 @@
+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
+- Mark each task complete immediately when finished
+- If blocked, document the blocker and move to next task`;
+export function registerTodoEnforcer(api) {
+    api.registerHook('agent:bootstrap', (event) => {
+        const config = getConfig(api);
+        if (!config.todo_enforcer_enabled) {
+            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');
+    }, {
+        name: 'oh-my-openclaw.todo-enforcer',
+        description: 'Injects TODO continuation directive into agent bootstrap',
+    });
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,95 @@
+import { PLUGIN_ID } from './types.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 { 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';
+export default function register(api) {
+    const config = getConfig(api);
+    api.logger.info(`[${PLUGIN_ID}] Initializing plugin v0.1.0`);
+    try {
+        registerTodoEnforcer(api);
+        api.logger.info(`[${PLUGIN_ID}] Todo Enforcer hook registered (enabled: ${config.todo_enforcer_enabled})`);
+    }
+    catch (err) {
+        api.logger.error(`[${PLUGIN_ID}] Failed to register Todo Enforcer:`, err);
+    }
+    try {
+        registerCommentChecker(api);
+        api.logger.info(`[${PLUGIN_ID}] Comment Checker hook registered (enabled: ${config.comment_checker_enabled})`);
+    }
+    catch (err) {
+        api.logger.error(`[${PLUGIN_ID}] Failed to register Comment Checker:`, err);
+    }
+    try {
+        registerMessageMonitor(api);
+        api.logger.info(`[${PLUGIN_ID}] Message Monitor hook registered`);
+    }
+    catch (err) {
+        api.logger.error(`[${PLUGIN_ID}] Failed to register Message Monitor:`, err);
+    }
+    try {
+        registerRalphLoop(api);
+        api.logger.info(`[${PLUGIN_ID}] Ralph Loop service registered`);
+    }
+    catch (err) {
+        api.logger.error(`[${PLUGIN_ID}] Failed to register Ralph Loop:`, err);
+    }
+    try {
+        registerDelegateTool(api);
+        api.logger.info(`[${PLUGIN_ID}] Delegate tool registered`);
+    }
+    catch (err) {
+        api.logger.error(`[${PLUGIN_ID}] Failed to register Delegate tool:`, err);
+    }
+    try {
+        registerLookAtTool(api);
+        api.logger.info(`[${PLUGIN_ID}] Look-At tool registered`);
+    }
+    catch (err) {
+        api.logger.error(`[${PLUGIN_ID}] Failed to register Look-At tool:`, err);
+    }
+    try {
+        registerCheckpointTool(api);
+        api.logger.info(`[${PLUGIN_ID}] Checkpoint tool registered`);
+    }
+    catch (err) {
+        api.logger.error(`[${PLUGIN_ID}] Failed to register Checkpoint tool:`, err);
+    }
+    try {
+        registerWorkflowCommands(api);
+        api.logger.info(`[${PLUGIN_ID}] Workflow commands registered (ultrawork, plan, start-work)`);
+    }
+    catch (err) {
+        api.logger.error(`[${PLUGIN_ID}] Failed to register Workflow commands:`, err);
+    }
+    try {
+        registerRalphCommands(api);
+        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);
+    }
+    api.registerGatewayMethod('oh-my-openclaw.status', () => {
+        return {
+            ok: true,
+            plugin: PLUGIN_ID,
+            version: '0.1.0',
+            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'],
+            config: {
+                todo_enforcer_enabled: config.todo_enforcer_enabled,
+                comment_checker_enabled: config.comment_checker_enabled,
+                max_ralph_iterations: config.max_ralph_iterations,
+            },
+        };
+    });
+    api.logger.info(`[${PLUGIN_ID}] Plugin initialization complete`);
+}

package/dist/services/ralph-loop.d.ts

@@ -0,0 +1,17 @@
+import { OmocPluginApi, RalphLoopState } from '../types.js';
+export declare function registerRalphLoop(api: OmocPluginApi): void;
+export declare function startLoop(taskFile: string, maxIterations: number): Promise<{
+    success: boolean;
+    message: string;
+    state: RalphLoopState;
+}>;
+export declare function stopLoop(): Promise<{
+    success: boolean;
+    message: string;
+    state: RalphLoopState;
+}>;
+export declare function getStatus(): Promise<RalphLoopState>;
+export declare function incrementIteration(): Promise<{
+    continue: boolean;
+    state: RalphLoopState;
+}>;

package/dist/services/ralph-loop.js

@@ -0,0 +1,127 @@
+import { promises as fs } from 'fs';
+import { join } from 'path';
+import { ABSOLUTE_MAX_RALPH_ITERATIONS, PLUGIN_ID, } from '../types.js';
+import { readState, writeState } from '../utils/state.js';
+import { clampIterations } from '../utils/validation.js';
+const DEFAULT_STATE = {
+    active: false,
+    iteration: 0,
+    maxIterations: 10,
+    taskFile: '',
+    startedAt: '',
+};
+let apiRef = null;
+let stateFilePath = '';
+let currentState = { ...DEFAULT_STATE };
+function getApi() {
+    if (!apiRef) {
+        throw new Error('Ralph Loop service is not registered');
+    }
+    return apiRef;
+}
+async function loadStateFromFile() {
+    if (!stateFilePath) {
+        currentState = { ...DEFAULT_STATE };
+        return;
+    }
+    const loadedState = await readState(stateFilePath);
+    if (loadedState) {
+        currentState = loadedState;
+        return;
+    }
+    let hasExistingFile = false;
+    try {
+        await fs.access(stateFilePath);
+        hasExistingFile = true;
+    }
+    catch {
+        hasExistingFile = false;
+    }
+    currentState = { ...DEFAULT_STATE };
+    if (hasExistingFile) {
+        getApi().logger.warn(`[${PLUGIN_ID}] Ralph Loop state was corrupted; recovering with default state`);
+    }
+}
+async function saveStateToFile() {
+    if (!stateFilePath) {
+        return;
+    }
+    await writeState(stateFilePath, currentState);
+}
+export function registerRalphLoop(api) {
+    apiRef = api;
+    stateFilePath = join(api.config.checkpoint_dir, 'ralph-loop-state.json');
+    api.registerService({
+        id: 'omoc-ralph-loop',
+        name: 'Ralph Loop Service',
+        description: 'Self-referential completion mechanism with configurable iterations',
+        start: async () => {
+            await loadStateFromFile();
+        },
+        stop: async () => {
+            await saveStateToFile();
+        },
+    });
+}
+export async function startLoop(taskFile, maxIterations) {
+    const api = getApi();
+    if (currentState.active) {
+        return {
+            success: false,
+            message: 'Ralph Loop is already running',
+            state: currentState,
+        };
+    }
+    const clampedIterations = clampIterations(maxIterations, ABSOLUTE_MAX_RALPH_ITERATIONS);
+    currentState = {
+        active: true,
+        iteration: 0,
+        maxIterations: clampedIterations,
+        taskFile,
+        startedAt: new Date().toISOString(),
+    };
+    await saveStateToFile();
+    api.logger.info('[omoc] Ralph Loop started');
+    return {
+        success: true,
+        message: 'Ralph Loop started',
+        state: currentState,
+    };
+}
+export async function stopLoop() {
+    const api = getApi();
+    currentState = {
+        ...currentState,
+        active: false,
+    };
+    await saveStateToFile();
+    api.logger.info('[omoc] Ralph Loop stopped');
+    return {
+        success: true,
+        message: 'Ralph Loop stopped',
+        state: currentState,
+    };
+}
+export async function getStatus() {
+    return currentState;
+}
+export async function incrementIteration() {
+    if (!currentState.active) {
+        return {
+            continue: false,
+            state: currentState,
+        };
+    }
+    const nextIteration = currentState.iteration + 1;
+    const reachedLimit = nextIteration >= currentState.maxIterations;
+    currentState = {
+        ...currentState,
+        iteration: nextIteration,
+        active: reachedLimit ? false : currentState.active,
+    };
+    await saveStateToFile();
+    return {
+        continue: currentState.active,
+        state: currentState,
+    };
+}

package/dist/tools/checkpoint.d.ts

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

package/dist/tools/checkpoint.js

@@ -0,0 +1,125 @@
+import { Type } from '@sinclair/typebox';
+import { promises as fs } from 'fs';
+import { join } from 'path';
+import { readState, writeState, ensureDir } from '../utils/state.js';
+import { getConfig } from '../utils/config.js';
+export function registerCheckpointTool(api) {
+    api.registerTool({
+        name: 'omoc_checkpoint',
+        description: 'Save, load, or list session checkpoints for crash recovery',
+        parameters: 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' })),
+        }),
+        execute: async (params) => {
+            const config = getConfig(api);
+            const checkpointDir = config.checkpoint_dir;
+            await ensureDir(checkpointDir);
+            if (params.action === 'save') {
+                const checkpoint = {
+                    type: 'session-checkpoint',
+                    session_id: `checkpoint-${Date.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(),
+                };
+                const filename = `checkpoint-${Date.now()}.json`;
+                await writeState(join(checkpointDir, filename), checkpoint);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({ saved: filename, checkpoint }, null, 2),
+                        },
+                    ],
+                };
+            }
+            if (params.action === 'load') {
+                try {
+                    const files = await fs.readdir(checkpointDir);
+                    const jsonFiles = files.filter((f) => f.endsWith('.json')).sort().reverse();
+                    if (jsonFiles.length === 0) {
+                        return {
+                            content: [{ type: 'text', text: 'No checkpoints found' }],
+                        };
+                    }
+                    const mostRecent = jsonFiles[0];
+                    const checkpoint = await readState(join(checkpointDir, mostRecent));
+                    if (!checkpoint) {
+                        return {
+                            content: [{ type: 'text', text: `Failed to load checkpoint: ${mostRecent}` }],
+                        };
+                    }
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({ loaded: mostRecent, checkpoint }, null, 2),
+                            },
+                        ],
+                    };
+                }
+                catch (error) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `Error loading checkpoint: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                            },
+                        ],
+                    };
+                }
+            }
+            if (params.action === 'list') {
+                try {
+                    const files = await fs.readdir(checkpointDir);
+                    const jsonFiles = files.filter((f) => f.endsWith('.json')).sort().reverse();
+                    if (jsonFiles.length === 0) {
+                        return {
+                            content: [{ type: 'text', text: 'No checkpoints found' }],
+                        };
+                    }
+                    const checkpoints = await Promise.all(jsonFiles.map(async (file) => {
+                        const checkpoint = await readState(join(checkpointDir, file));
+                        return {
+                            file,
+                            timestamp: checkpoint?.timestamp || 'unknown',
+                            task: checkpoint?.task || 'unknown',
+                            step: checkpoint?.step || 'unknown',
+                        };
+                    }));
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({ checkpoints }, null, 2),
+                            },
+                        ],
+                    };
+                }
+                catch (error) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `Error listing checkpoints: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                            },
+                        ],
+                    };
+                }
+            }
+            return {
+                content: [{ type: 'text', text: 'Invalid action' }],
+            };
+        },
+        optional: true,
+    });
+}

package/dist/tools/look-at.d.ts

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

package/dist/tools/look-at.js

@@ -0,0 +1,67 @@
+import { Type } from '@sinclair/typebox';
+import { execSync } from 'child_process';
+import { promises as fs } from 'fs';
+import { TOOL_PREFIX } from '../types.js';
+const TMUX_SOCKET = '/tmp/openclaw-tmux-sockets/openclaw.sock';
+const TMUX_SESSION_TARGET = 'gemini:0.0';
+const GEMINI_TIMEOUT_MS = 60_000;
+function escapeShellArg(arg) {
+    return arg.replace(/'/g, "'\\''");
+}
+export function registerLookAtTool(api) {
+    api.registerTool({
+        name: `${TOOL_PREFIX}look_at`,
+        description: 'Analyze files (PDF, images, video) using Gemini CLI via tmux',
+        parameters: Type.Object({
+            file_path: Type.String({ description: 'Path to the file to analyze' }),
+            goal: Type.String({ description: 'What to analyze or look for' }),
+            model: Type.Optional(Type.String({
+                description: 'Gemini model to use',
+                default: 'gemini-2.5-flash',
+            })),
+        }),
+        execute: async (params) => {
+            const tempFile = `/tmp/omoc-look-at-${Date.now()}.md`;
+            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`;
+                execSync(tmuxCommand, { timeout: 5000 });
+                const startTime = Date.now();
+                while (Date.now() - startTime < GEMINI_TIMEOUT_MS) {
+                    try {
+                        const stat = await fs.stat(tempFile);
+                        if (stat.size > 0) {
+                            const result = await fs.readFile(tempFile, 'utf-8');
+                            await fs.unlink(tempFile);
+                            return { content: [{ type: 'text', text: result }] };
+                        }
+                    }
+                    catch { }
+                    await new Promise((resolve) => setTimeout(resolve, 2000));
+                }
+                try {
+                    await fs.unlink(tempFile);
+                }
+                catch { }
+                return {
+                    content: [
+                        { type: 'text', text: 'Error: Gemini CLI timed out after 60 seconds' },
+                    ],
+                };
+            }
+            catch (error) {
+                try {
+                    await fs.unlink(tempFile);
+                }
+                catch { }
+                const message = error instanceof Error ? error.message : String(error);
+                return { content: [{ type: 'text', text: `Error: ${message}` }] };
+            }
+        },
+        optional: true,
+    });
+}

package/dist/tools/task-delegation.d.ts

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

package/dist/tools/task-delegation.js

@@ -0,0 +1,61 @@
+import { Type } from '@sinclair/typebox';
+import { TOOL_PREFIX } from '../types.js';
+import { isValidCategory } from '../utils/validation.js';
+const CATEGORY_MODELS = {
+    quick: 'cliproxy/claude-sonnet-4-6',
+    deep: 'cliproxy/claude-opus-4-6-thinking',
+    ultrabrain: 'cliproxy/gpt-5.3-codex',
+    'visual-engineering': 'cliproxy/gemini-3.1-pro',
+    multimodal: 'gemini-2.5-flash',
+    artistry: 'cliproxy/claude-opus-4-6-thinking',
+    'unspecified-low': 'cliproxy/claude-sonnet-4-6',
+    'unspecified-high': 'cliproxy/claude-opus-4-6-thinking',
+    writing: 'cliproxy/claude-sonnet-4-6',
+};
+const DelegateParamsSchema = Type.Object({
+    task_description: Type.String({ description: 'What the sub-agent should do' }),
+    category: Type.String({ description: 'Task category for model routing (quick, deep, ultrabrain, etc.)' }),
+    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 })),
+});
+export function registerDelegateTool(api) {
+    api.registerTool({
+        name: `${TOOL_PREFIX}delegate`,
+        description: 'Delegate a task to a sub-agent with category-based model routing',
+        parameters: DelegateParamsSchema,
+        execute: async (params) => {
+            const validCategories = Object.keys(CATEGORY_MODELS);
+            if (!isValidCategory(params.category)) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                error: `Invalid category: ${params.category}`,
+                                valid_categories: validCategories,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            const model = CATEGORY_MODELS[params.category];
+            api.logger.info('[omoc] Delegating task:', { category: params.category, model });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            action: 'delegate',
+                            task_description: params.task_description,
+                            category: params.category,
+                            model,
+                            skills: params.skills || [],
+                            background: params.background || false,
+                        }, null, 2),
+                    },
+                ],
+            };
+        },
+        optional: true,
+    });
+}

package/dist/types.d.ts

@@ -0,0 +1,73 @@
+export declare const ABSOLUTE_MAX_RALPH_ITERATIONS = 100;
+export declare const TOOL_PREFIX = "omoc_";
+export declare const PLUGIN_ID = "oh-my-openclaw";
+export interface PluginConfig {
+    max_ralph_iterations: number;
+    todo_enforcer_enabled: boolean;
+    todo_enforcer_cooldown_ms: number;
+    todo_enforcer_max_failures: number;
+    comment_checker_enabled: boolean;
+    notepad_dir: string;
+    plans_dir: string;
+    checkpoint_dir: string;
+}
+export interface RalphLoopState {
+    active: boolean;
+    iteration: number;
+    maxIterations: number;
+    taskFile: string;
+    startedAt: string;
+}
+export interface CheckpointData {
+    type: 'session-checkpoint';
+    session_id: string;
+    task: string;
+    step: string;
+    changed_files: string[];
+    verification: {
+        diagnostics: 'pass' | 'fail' | 'not-run';
+        tests: 'pass' | 'fail' | 'not-run';
+        build: 'pass' | 'fail' | 'not-run';
+    };
+    next_action: string;
+    timestamp: string;
+}
+export interface TodoItem {
+    id: string;
+    content: string;
+    status: 'pending' | 'in_progress' | 'completed' | 'cancelled';
+    priority: string;
+}
+export interface CommentViolation {
+    file: string;
+    line: number;
+    content: string;
+    reason: string;
+}
+export interface DelegationParams {
+    task: string;
+    category: string;
+    agentId?: string;
+    skills?: string[];
+    context?: string;
+}
+export interface CategoryConfig {
+    model: string;
+    description: string;
+    agents?: string[];
+    alternatives?: string[];
+    tool?: string;
+}
+export interface OmocPluginApi {
+    config: PluginConfig;
+    logger: {
+        info: (...args: any[]) => void;
+        warn: (...args: any[]) => void;
+        error: (...args: any[]) => void;
+    };
+    registerHook: (event: string, handler: any, meta?: any) => void;
+    registerTool: (config: any) => void;
+    registerCommand: (config: any) => void;
+    registerService: (config: any) => void;
+    registerGatewayMethod: (name: string, handler: any) => void;
+}

package/dist/types.js

@@ -0,0 +1,4 @@
+// Constants
+export const ABSOLUTE_MAX_RALPH_ITERATIONS = 100;
+export const TOOL_PREFIX = 'omoc_';
+export const PLUGIN_ID = 'oh-my-openclaw';

package/dist/utils/config.d.ts

@@ -0,0 +1,6 @@
+import { PluginConfig, OmocPluginApi } from '../types.js';
+export declare function getConfig(api: OmocPluginApi): PluginConfig;
+export declare function validateConfig(config: Partial<PluginConfig>): {
+    valid: boolean;
+    errors: string[];
+};

package/dist/utils/config.js

@@ -0,0 +1,44 @@
+import { ABSOLUTE_MAX_RALPH_ITERATIONS } from '../types.js';
+export function getConfig(api) {
+    const defaults = {
+        max_ralph_iterations: 10,
+        todo_enforcer_enabled: true,
+        todo_enforcer_cooldown_ms: 2000,
+        todo_enforcer_max_failures: 5,
+        comment_checker_enabled: true,
+        notepad_dir: 'workspace/notepads',
+        plans_dir: 'workspace/plans',
+        checkpoint_dir: 'workspace/checkpoints',
+    };
+    const config = { ...defaults, ...api.config };
+    const validation = validateConfig(config);
+    if (!validation.valid) {
+        api.logger.warn(`Config validation failed: ${validation.errors.join(', ')}`);
+    }
+    if (config.max_ralph_iterations > ABSOLUTE_MAX_RALPH_ITERATIONS) {
+        config.max_ralph_iterations = ABSOLUTE_MAX_RALPH_ITERATIONS;
+    }
+    return config;
+}
+export function validateConfig(config) {
+    const errors = [];
+    if (config.max_ralph_iterations !== undefined) {
+        if (config.max_ralph_iterations < 0 || config.max_ralph_iterations > ABSOLUTE_MAX_RALPH_ITERATIONS) {
+            errors.push(`max_ralph_iterations must be between 0 and ${ABSOLUTE_MAX_RALPH_ITERATIONS}`);
+        }
+    }
+    if (config.todo_enforcer_cooldown_ms !== undefined) {
+        if (config.todo_enforcer_cooldown_ms <= 0) {
+            errors.push('todo_enforcer_cooldown_ms must be greater than 0');
+        }
+    }
+    if (config.todo_enforcer_max_failures !== undefined) {
+        if (config.todo_enforcer_max_failures < 1) {
+            errors.push('todo_enforcer_max_failures must be at least 1');
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}

package/dist/utils/state.d.ts

@@ -0,0 +1,3 @@
+export declare function readState<T>(filePath: string): Promise<T | null>;
+export declare function writeState<T>(filePath: string, data: T): Promise<void>;
+export declare function ensureDir(dirPath: string): Promise<void>;

package/dist/utils/state.js

@@ -0,0 +1,29 @@
+import { promises as fs } from 'fs';
+import { dirname } from 'path';
+export async function readState(filePath) {
+    try {
+        const data = await fs.readFile(filePath, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return null;
+        }
+        return null;
+    }
+}
+export async function writeState(filePath, data) {
+    await ensureDir(dirname(filePath));
+    const jsonContent = JSON.stringify(data, null, 2);
+    await fs.writeFile(filePath, jsonContent, 'utf-8');
+}
+export async function ensureDir(dirPath) {
+    try {
+        await fs.mkdir(dirPath, { recursive: true });
+    }
+    catch (error) {
+        if (error.code !== 'EEXIST') {
+            throw error;
+        }
+    }
+}

package/dist/utils/validation.d.ts

@@ -0,0 +1,3 @@
+export declare function isValidCategory(cat: string): boolean;
+export declare function sanitizeToolName(name: string): string;
+export declare function clampIterations(n: number, max?: number): number;

package/dist/utils/validation.js

@@ -0,0 +1,26 @@
+import { TOOL_PREFIX, ABSOLUTE_MAX_RALPH_ITERATIONS } from '../types.js';
+const VALID_CATEGORIES = [
+    'quick',
+    'deep',
+    'ultrabrain',
+    'visual-engineering',
+    'multimodal',
+    'artistry',
+    'unspecified-low',
+    'unspecified-high',
+    'writing',
+];
+export function isValidCategory(cat) {
+    return VALID_CATEGORIES.includes(cat);
+}
+export function sanitizeToolName(name) {
+    let sanitized = name.toLowerCase();
+    sanitized = sanitized.replace(/[^a-z0-9_]/g, '_');
+    if (!sanitized.startsWith(TOOL_PREFIX)) {
+        sanitized = TOOL_PREFIX + sanitized;
+    }
+    return sanitized;
+}
+export function clampIterations(n, max = ABSOLUTE_MAX_RALPH_ITERATIONS) {
+    return Math.max(0, Math.min(n, max));
+}

package/openclaw.plugin.json

@@ -0,0 +1,54 @@
+{
+  "id": "oh-my-openclaw",
+  "name": "Oh-My-OpenClaw",
+  "description": "Multi-agent orchestration plugin with todo enforcer, ralph loop, comment checker, and custom delegation tools",
+  "version": "0.1.0",
+  "skills": ["../skills"],
+  "tools": ["omoc_delegate", "omoc_look_at", "omoc_checkpoint"],
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "max_ralph_iterations": {
+        "type": "number",
+        "default": 10,
+        "description": "Maximum ralph loop iterations before auto-stop"
+      },
+      "todo_enforcer_enabled": {
+        "type": "boolean",
+        "default": true,
+        "description": "Enable todo continuation enforcement on session idle"
+      },
+      "todo_enforcer_cooldown_ms": {
+        "type": "number",
+        "default": 2000,
+        "description": "Cooldown in ms before injecting continuation prompt"
+      },
+      "todo_enforcer_max_failures": {
+        "type": "number",
+        "default": 5,
+        "description": "Max consecutive failures before extended pause"
+      },
+      "comment_checker_enabled": {
+        "type": "boolean",
+        "default": true,
+        "description": "Enable AI slop comment detection"
+      },
+      "notepad_dir": {
+        "type": "string",
+        "default": "workspace/notepads",
+        "description": "Directory for wisdom notepad files"
+      },
+      "plans_dir": {
+        "type": "string",
+        "default": "workspace/plans",
+        "description": "Directory for plan files"
+      },
+      "checkpoint_dir": {
+        "type": "string",
+        "default": "workspace/checkpoints",
+        "description": "Directory for checkpoint files"
+      }
+    }
+  }
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@happycastle/oh-my-openclaw",
+  "version": "0.1.0",
+  "description": "Oh-My-OpenClaw plugin — multi-agent orchestration, todo enforcer, ralph loop, and custom tools for OpenClaw",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "node --experimental-vm-modules node_modules/.bin/vitest run",
+    "test:watch": "node --experimental-vm-modules node_modules/.bin/vitest",
+    "typecheck": "tsc --noEmit",
+    "lint": "tsc --noEmit",
+    "prepublishOnly": "npm run typecheck && npm run test && npm run build"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "openclaw": {
+    "extensions": [
+      "dist/index.js"
+    ]
+  },
+  "files": [
+    "dist",
+    "openclaw.plugin.json",
+    "skills"
+  ],
+  "keywords": [
+    "openclaw",
+    "plugin",
+    "multi-agent",
+    "orchestration"
+  ],
+  "license": "UNLICENSED",
+  "author": "happycastle",
+  "devDependencies": {
+    "@sinclair/typebox": "^0.34.0",
+    "@types/node": "^25.3.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  }
+}