@happycastle/oh-my-openclaw 0.5.0 → 0.6.0

package/dist/agents/agent-configs.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Defines the Oh-My-OpenClaw plugin's local agent configuration contracts
+ * and the canonical list of built-in OMOC agent definitions.
+ */
+export type OmocAgentConfig = {
+    id: string;
+    name?: string;
+    model?: string | {
+        primary: string;
+        fallbacks?: string[];
+    };
+    skills?: string[];
+    identity?: {
+        name?: string;
+        theme?: string;
+        emoji?: string;
+    };
+    subagents?: {
+        allowAgents?: string[];
+        model?: string | {
+            primary: string;
+            fallbacks?: string[];
+        };
+    };
+    tools?: {
+        profile?: 'minimal' | 'coding' | 'messaging' | 'full';
+        allow?: string[];
+        deny?: string[];
+    };
+};
+export declare const OMOC_AGENT_CONFIGS: OmocAgentConfig[];

package/dist/agents/agent-configs.js

@@ -0,0 +1,188 @@
+export const OMOC_AGENT_CONFIGS = [
+    // Strategic planning agent.
+    {
+        id: 'omoc_prometheus',
+        name: 'Prometheus',
+        model: {
+            primary: 'openai/o3',
+            fallbacks: ['anthropic/claude-opus-4-6'],
+        },
+        identity: {
+            name: 'Prometheus',
+            emoji: '🔥',
+            theme: 'Strategic Planner',
+        },
+        tools: { profile: 'full' },
+        subagents: { allowAgents: ['*'] },
+    },
+    // Task orchestration coordinator (cheap/fast tier — lightweight orchestrator).
+    {
+        id: 'omoc_atlas',
+        name: 'Atlas',
+        model: {
+            primary: 'anthropic/claude-sonnet-4-6',
+            fallbacks: ['openai/gpt-4.1'],
+        },
+        identity: {
+            name: 'Atlas',
+            emoji: '🗺️',
+            theme: 'Task Orchestrator',
+        },
+        tools: { profile: 'full' },
+        subagents: { allowAgents: ['*'] },
+    },
+    // Primary implementation worker (opus-tier — high-quality output).
+    {
+        id: 'omoc_sisyphus',
+        name: 'Sisyphus-Junior',
+        model: {
+            primary: 'anthropic/claude-opus-4-6',
+            fallbacks: ['openai/o3'],
+        },
+        identity: {
+            name: 'Sisyphus-Junior',
+            emoji: '🪨',
+            theme: 'Implementation Worker',
+        },
+        tools: { profile: 'full' },
+        subagents: {
+            allowAgents: ['omoc_explore', 'omoc_librarian', 'omoc_oracle'],
+        },
+    },
+    // Deep implementation specialist.
+    {
+        id: 'omoc_hephaestus',
+        name: 'Hephaestus',
+        model: {
+            primary: 'anthropic/claude-opus-4-6',
+            fallbacks: ['openai/o3'],
+        },
+        identity: {
+            name: 'Hephaestus',
+            emoji: '🔨',
+            theme: 'Deep Implementation',
+        },
+        tools: { profile: 'full' },
+        subagents: {
+            allowAgents: ['omoc_explore', 'omoc_librarian', 'omoc_oracle'],
+        },
+    },
+    // Read-only architecture consultant.
+    {
+        id: 'omoc_oracle',
+        name: 'Oracle',
+        model: {
+            primary: 'openai/o3',
+            fallbacks: ['anthropic/claude-opus-4-6'],
+        },
+        identity: {
+            name: 'Oracle',
+            emoji: '🏛️',
+            theme: 'Architecture Consultant',
+        },
+        tools: {
+            profile: 'coding',
+            deny: ['write', 'edit', 'apply_patch', 'sessions_spawn'],
+        },
+    },
+    // Read-only codebase search specialist.
+    {
+        id: 'omoc_explore',
+        name: 'Explore',
+        model: 'anthropic/claude-sonnet-4-6',
+        identity: {
+            name: 'Explore',
+            emoji: '🔍',
+            theme: 'Codebase Search',
+        },
+        tools: {
+            profile: 'coding',
+            deny: ['write', 'edit', 'apply_patch', 'sessions_spawn'],
+        },
+    },
+    // Read-only documentation research specialist.
+    {
+        id: 'omoc_librarian',
+        name: 'Librarian',
+        model: 'anthropic/claude-sonnet-4-6',
+        identity: {
+            name: 'Librarian',
+            emoji: '📚',
+            theme: 'Documentation Research',
+        },
+        tools: {
+            profile: 'coding',
+            deny: ['write', 'edit', 'apply_patch', 'sessions_spawn'],
+        },
+    },
+    // Read-only pre-planning analyst.
+    {
+        id: 'omoc_metis',
+        name: 'Metis',
+        model: {
+            primary: 'anthropic/claude-opus-4-6',
+            fallbacks: ['openai/o3'],
+        },
+        identity: {
+            name: 'Metis',
+            emoji: '🧠',
+            theme: 'Pre-Planning Analyst',
+        },
+        tools: {
+            profile: 'coding',
+            deny: ['write', 'edit', 'apply_patch', 'sessions_spawn'],
+        },
+    },
+    // Read-only plan review specialist.
+    {
+        id: 'omoc_momus',
+        name: 'Momus',
+        model: {
+            primary: 'anthropic/claude-opus-4-6',
+            fallbacks: ['openai/o3'],
+        },
+        identity: {
+            name: 'Momus',
+            emoji: '🎭',
+            theme: 'Plan Reviewer',
+        },
+        tools: {
+            profile: 'coding',
+            deny: ['write', 'edit', 'apply_patch', 'sessions_spawn'],
+        },
+    },
+    // Multimodal visual analysis specialist (read-only — allowlist approach).
+    {
+        id: 'omoc_looker',
+        name: 'Multimodal Looker',
+        model: {
+            primary: 'google/gemini-2.5-flash',
+            fallbacks: ['anthropic/claude-sonnet-4-6'],
+        },
+        identity: {
+            name: 'Multimodal Looker',
+            emoji: '👁️',
+            theme: 'Visual Analysis',
+        },
+        tools: {
+            allow: ['read'],
+            deny: ['write', 'edit', 'apply_patch', 'sessions_spawn'],
+        },
+    },
+    // Frontend-focused visual engineering specialist.
+    {
+        id: 'omoc_frontend',
+        name: 'Frontend',
+        model: {
+            primary: 'google/gemini-2.5-pro',
+            fallbacks: ['anthropic/claude-sonnet-4-6'],
+        },
+        identity: {
+            name: 'Frontend',
+            emoji: '🎨',
+            theme: 'Visual Engineering',
+        },
+        tools: { profile: 'coding' },
+        subagents: { allowAgents: ['omoc_explore', 'omoc_librarian'] },
+    },
+];

package/dist/cli/setup.d.ts

@@ -0,0 +1,60 @@
+import { type OmocAgentConfig } from '../agents/agent-configs.js';
+type AgentsSection = {
+    defaults?: Record<string, unknown>;
+    list?: Array<{
+        id: string;
+        [key: string]: unknown;
+    }>;
+};
+type ConfigShape = {
+    agents?: AgentsSection;
+    [key: string]: unknown;
+};
+type Logger = {
+    info: (msg: string) => void;
+    warn: (msg: string) => void;
+    error: (msg: string) => void;
+};
+export declare function findConfigPath(workspaceDir?: string): string | undefined;
+/**
+ * Lenient JSON5 parser: strips // and /* comments, removes trailing commas,
+ * then delegates to JSON.parse.
+ */
+export declare function parseConfig(raw: string): ConfigShape;
+export declare function serializeConfig(config: ConfigShape): string;
+export interface MergeResult {
+    added: string[];
+    skipped: string[];
+    updated: string[];
+}
+export declare function mergeAgentConfigs(existing: Array<{
+    id: string;
+    [key: string]: unknown;
+}>, incoming: OmocAgentConfig[], force: boolean): {
+    merged: Array<{
+        id: string;
+        [key: string]: unknown;
+    }>;
+    result: MergeResult;
+};
+export interface SetupOptions {
+    configPath?: string;
+    workspaceDir?: string;
+    force?: boolean;
+    dryRun?: boolean;
+    logger: Logger;
+}
+export declare function runSetup(options: SetupOptions): MergeResult;
+export declare function registerSetupCli(ctx: {
+    program: {
+        command: (name: string) => CommandBuilder;
+    };
+    workspaceDir?: string;
+    logger: Logger;
+}): void;
+type CommandBuilder = {
+    description: (desc: string) => CommandBuilder;
+    option: (flags: string, desc: string, defaultValue?: unknown) => CommandBuilder;
+    action: (fn: (...args: unknown[]) => void) => CommandBuilder;
+};
+export {};

package/dist/cli/setup.js

@@ -0,0 +1,145 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { OMOC_AGENT_CONFIGS } from '../agents/agent-configs.js';
+const CONFIG_FILENAMES = [
+    'openclaw.json5',
+    'openclaw.json',
+    'openclaw.yaml',
+    'openclaw.yml',
+];
+export function findConfigPath(workspaceDir) {
+    const searchDirs = [];
+    if (workspaceDir) {
+        searchDirs.push(workspaceDir);
+        const parent = path.dirname(workspaceDir);
+        if (parent !== workspaceDir) {
+            searchDirs.push(parent);
+        }
+    }
+    searchDirs.push(process.cwd());
+    const homeDir = process.env['HOME'] ?? process.env['USERPROFILE'];
+    if (homeDir) {
+        searchDirs.push(path.join(homeDir, '.openclaw'));
+    }
+    for (const dir of searchDirs) {
+        for (const filename of CONFIG_FILENAMES) {
+            const candidate = path.join(dir, filename);
+            if (fs.existsSync(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Lenient JSON5 parser: strips // and /* comments, removes trailing commas,
+ * then delegates to JSON.parse.
+ */
+export function parseConfig(raw) {
+    const stripped = raw
+        .replace(/\/\/.*$/gm, '')
+        .replace(/\/\*[\s\S]*?\*\//g, '')
+        .replace(/,\s*([\]}])/g, '$1');
+    return JSON.parse(stripped);
+}
+export function serializeConfig(config) {
+    return JSON.stringify(config, null, 2) + '\n';
+}
+export function mergeAgentConfigs(existing, incoming, force) {
+    const result = { added: [], skipped: [], updated: [] };
+    const merged = [...existing];
+    const existingIds = new Set(existing.map((a) => a.id));
+    for (const agent of incoming) {
+        if (existingIds.has(agent.id)) {
+            if (force) {
+                const idx = merged.findIndex((a) => a.id === agent.id);
+                if (idx !== -1) {
+                    merged[idx] = agent;
+                    result.updated.push(agent.id);
+                }
+            }
+            else {
+                result.skipped.push(agent.id);
+            }
+        }
+        else {
+            merged.push(agent);
+            result.added.push(agent.id);
+        }
+    }
+    return { merged, result };
+}
+export function runSetup(options) {
+    const { logger, force = false, dryRun = false } = options;
+    const configPath = options.configPath ?? findConfigPath(options.workspaceDir);
+    if (!configPath) {
+        throw new Error('Could not find OpenClaw config file. Searched for: ' +
+            CONFIG_FILENAMES.join(', ') +
+            '\nSpecify the path with --config <path>');
+    }
+    if (!fs.existsSync(configPath)) {
+        throw new Error(`Config file not found: ${configPath}`);
+    }
+    logger.info(`Found config: ${configPath}`);
+    const raw = fs.readFileSync(configPath, 'utf-8');
+    if (configPath.endsWith('.yaml') || configPath.endsWith('.yml')) {
+        throw new Error('YAML config files are not supported by omoc-setup. ' +
+            'Please convert to JSON or JSON5, or manually add agent configs.');
+    }
+    const config = parseConfig(raw);
+    if (!config.agents) {
+        config.agents = {};
+    }
+    if (!config.agents.list) {
+        config.agents.list = [];
+    }
+    const { merged, result } = mergeAgentConfigs(config.agents.list, OMOC_AGENT_CONFIGS, force);
+    config.agents.list = merged;
+    if (dryRun) {
+        logger.info('[dry-run] Would write config to: ' + configPath);
+    }
+    else {
+        const backupPath = configPath + '.bak';
+        fs.copyFileSync(configPath, backupPath);
+        logger.info(`Backup created: ${backupPath}`);
+        fs.writeFileSync(configPath, serializeConfig(config), 'utf-8');
+        logger.info(`Config updated: ${configPath}`);
+    }
+    if (result.added.length > 0) {
+        logger.info(`Added ${result.added.length} agent(s): ${result.added.join(', ')}`);
+    }
+    if (result.updated.length > 0) {
+        logger.info(`Updated ${result.updated.length} agent(s): ${result.updated.join(', ')}`);
+    }
+    if (result.skipped.length > 0) {
+        logger.info(`Skipped ${result.skipped.length} existing agent(s): ${result.skipped.join(', ')}`);
+    }
+    if (result.added.length === 0 && result.updated.length === 0) {
+        logger.info('No changes needed — all OmOC agents already present.');
+    }
+    return result;
+}
+export function registerSetupCli(ctx) {
+    ctx.program
+        .command('setup')
+        .description('Inject OmOC agent definitions into your OpenClaw config')
+        .option('--force', 'Overwrite existing OmOC agent configs', false)
+        .option('--dry-run', 'Preview changes without writing', false)
+        .option('--config <path>', 'Path to OpenClaw config file')
+        .action((...args) => {
+        const opts = (args[0] ?? {});
+        try {
+            runSetup({
+                configPath: opts.config,
+                workspaceDir: ctx.workspaceDir,
+                force: opts.force,
+                dryRun: opts.dryRun,
+                logger: ctx.logger,
+            });
+        }
+        catch (err) {
+            ctx.logger.error(`Setup failed: ${err instanceof Error ? err.message : String(err)}`);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/commands/ralph-commands.js

@@ -2,10 +2,11 @@ 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
+    // /ralph_loop command
     api.registerCommand({
-        name: 'ralph-loop',
+        name: 'ralph_loop',
         description: 'Start the Ralph Loop self-completion mechanism',
+        acceptsArgs: true,
         handler: async (ctx) => {
             const args = (ctx.args || '').trim().split(/\s+/).filter(Boolean);
             const config = getConfig(api);
@@ -22,9 +23,9 @@ export function registerRalphCommands(api) {
             };
         },
     });
-    // /ralph-stop command
+    // /ralph_stop command
     api.registerCommand({
-        name: 'ralph-stop',
+        name: 'ralph_stop',
         description: 'Stop the active Ralph Loop',
         handler: async () => {
             const result = await stopLoop();
@@ -33,9 +34,9 @@ export function registerRalphCommands(api) {
             };
         },
     });
-    // /omoc-status command
+    // /omoc_status command
     api.registerCommand({
-        name: 'omoc-status',
+        name: 'omoc_status',
         description: 'Show Oh-My-OpenClaw plugin status',
         handler: async () => {
             const config = getConfig(api);

package/dist/commands/status-commands.js

@@ -5,7 +5,7 @@ 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',
+        name: 'omoc_health',
         description: 'Plugin health check (auto-reply, no AI invocation)',
         handler: async () => {
             const config = getConfig(api);
@@ -24,7 +24,7 @@ export function registerStatusCommands(api) {
         },
     });
     api.registerCommand({
-        name: 'omoc-config',
+        name: 'omoc_config',
         description: 'Show current plugin configuration (auto-reply)',
         handler: () => {
             const config = getConfig(api);

package/dist/commands/workflow-commands.js

@@ -17,7 +17,8 @@ async function readWorkflow(workflowName) {
 export function registerWorkflowCommands(api) {
     api.registerCommand({
         name: 'ultrawork',
-        description: 'Full planning \u2192 execution \u2192 verification workflow',
+        description: 'Full planning → execution → verification workflow',
+        acceptsArgs: true,
         handler: async (ctx) => {
             const taskDescription = ctx.args || 'No task specified';
             const workflow = await readWorkflow('ultrawork');
@@ -29,6 +30,7 @@ export function registerWorkflowCommands(api) {
     api.registerCommand({
         name: 'plan',
         description: 'Create a structured execution plan',
+        acceptsArgs: true,
         handler: async (ctx) => {
             const topic = ctx.args || 'No topic specified';
             const workflow = await readWorkflow('plan');
@@ -38,8 +40,9 @@ export function registerWorkflowCommands(api) {
         },
     });
     api.registerCommand({
-        name: 'start-work',
+        name: 'start_work',
         description: 'Execute an approved plan',
+        acceptsArgs: true,
         handler: async (ctx) => {
             const planPath = ctx.args || 'most recent plan';
             const workflow = await readWorkflow('start-work');

package/dist/index.js

@@ -12,12 +12,13 @@ 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 */
+import { registerSetupCli } from './cli/setup.js';
 const registry = {
     hooks: [],
     services: [],
     tools: [],
     commands: [],
+    cli: [],
 };
 export default function register(api) {
     const config = getConfig(api);
@@ -88,28 +89,42 @@ 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)`);
+        registry.commands.push('ultrawork', 'plan', 'start_work');
+        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);
-        registry.commands.push('ralph-loop', 'ralph-stop', 'omoc-status');
-        api.logger.info(`[${PLUGIN_ID}] Ralph commands registered (ralph-loop, ralph-stop, omoc-status)`);
+        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)`);
+        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);
     }
+    try {
+        api.registerCli((ctx) => {
+            registerSetupCli({
+                program: ctx.program,
+                workspaceDir: ctx.workspaceDir,
+                logger: ctx.logger,
+            });
+        }, { commands: ['setup'] });
+        registry.cli.push('setup');
+        api.logger.info(`[${PLUGIN_ID}] CLI command registered (setup)`);
+    }
+    catch (err) {
+        api.logger.error(`[${PLUGIN_ID}] Failed to register CLI:`, err);
+    }
     api.registerGatewayMethod('oh-my-openclaw.status', () => {
         return {
             ok: true,
@@ -119,6 +134,7 @@ export default function register(api) {
             services: [...registry.services],
             tools: [...registry.tools],
             commands: [...registry.commands],
+            cli: [...registry.cli],
             config: {
                 todo_enforcer_enabled: config.todo_enforcer_enabled,
                 comment_checker_enabled: config.comment_checker_enabled,

package/dist/tools/checkpoint.js

@@ -3,12 +3,14 @@ import { promises as fs } from 'fs';
 import { join } from 'path';
 import { readState, writeState, ensureDir } from '../utils/state.js';
 import { getConfig } from '../utils/config.js';
+// Use Type.Unsafe with enum instead of Type.Union([Type.Literal(...)]) to avoid
+// generating JSON Schema "const" keyword, which Gemini API does not support.
 const CheckpointParamsSchema = Type.Object({
-    action: Type.Union([
-        Type.Literal('save'),
-        Type.Literal('load'),
-        Type.Literal('list'),
-    ], { description: 'Checkpoint operation' }),
+    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' })),

package/dist/types.d.ts

@@ -85,6 +85,7 @@ export interface CommandRegistration<TCtx = {
 }> {
     name: string;
     description: string;
+    acceptsArgs?: boolean;
     handler: (ctx: TCtx) => {
         text: string;
     } | Promise<{
@@ -99,6 +100,7 @@ export interface ServiceRegistration {
     stop?: () => Promise<void>;
 }
 export interface OmocPluginApi {
+    pluginConfig?: PluginConfig;
     config: PluginConfig;
     logger: {
         info: (...args: unknown[]) => void;
@@ -112,4 +114,12 @@ export interface OmocPluginApi {
     }>(config: CommandRegistration<TCtx>) => void;
     registerService: (config: ServiceRegistration) => void;
     registerGatewayMethod: (name: string, handler: () => unknown) => void;
+    registerCli: (registrar: (ctx: {
+        program: unknown;
+        config: unknown;
+        workspaceDir?: string;
+        logger: OmocPluginApi['logger'];
+    }) => void | Promise<void>, opts?: {
+        commands?: string[];
+    }) => void;
 }

package/dist/utils/config.js

@@ -12,7 +12,7 @@ export function getConfig(api) {
         tmux_socket: '/tmp/openclaw-tmux-sockets/openclaw.sock',
         model_routing: undefined,
     };
-    const config = { ...defaults, ...api.config };
+    const config = { ...defaults, ...(api.pluginConfig ?? api.config) };
     const validation = validateConfig(config);
     if (!validation.valid) {
         api.logger.warn(`Config validation failed: ${validation.errors.join(', ')}`);

package/openclaw.plugin.json

@@ -1,8 +1,8 @@
 {
   "id": "oh-my-openclaw",
   "name": "Oh-My-OpenClaw",
-  "description": "Multi-agent orchestration plugin \u2014 10 agents, category-based model routing, todo enforcer, ralph loop, and custom tools",
-  "version": "0.5.0",
+  "description": "Multi-agent orchestration plugin \u2014 11 agents, category-based model routing, todo enforcer, ralph loop, agent setup CLI, and custom tools",
+  "version": "0.6.0",
   "skills": ["skills"],
   "configSchema": {
     "type": "object",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@happycastle/oh-my-openclaw",
-  "version": "0.5.0",
+  "version": "0.6.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/skills/workflow-tool-patterns.md

@@ -23,7 +23,7 @@ OmO의 `src/tools/` 구조를 기준으로, OpenClaw에서 실사용 가능한
 | `lsp/*` (goto/references) | 코드 탐색/검증       | `exec` 도구로 린터/타입체커 실행 → 결과로 검증                     |
 | `interactive-bash`        | 장시간/상호작용 셸   | `exec`(`pty: true`) 또는 tmux 연동                                 |
 | `bash`                    | 원샷 명령            | `exec`(동기), `exec`(`background: true`) → `process`(`poll`)       |
-| `slashcommand`            | 명령 워크플로우 구동 | OpenClaw 스킬 `/ultrawork`, `/plan`, `/start-work` (슬래시 커맨드) |
+| `slashcommand`            | 명령 워크플로우 구동 | OpenClaw 스킬 `/ultrawork`, `/plan`, `/start_work` (슬래시 커맨드) |
 | `session-manager`         | 세션 탐색/재개       | `sessions_list`, `sessions_history`, `session_status`              |
 | `skill-mcp`               | 스킬 기반 도구 호출  | OpenClaw 스킬 시스템 (`read` → SKILL.md 참조)                      |
 | `look-at`                 | 멀티모달 분석        | `image` 도구 + Gemini CLI tmux 연동                                |

package/workflows/plan.md

@@ -11,7 +11,7 @@ Strategic planning workflow that analyzes requirements and creates a structured
 - Starting a new feature or project
 - Complex multi-step tasks
 - When requirements are ambiguous and need clarification
-- Before any `/ultrawork` or `/start-work` invocation
+- Before any `/ultrawork` or `/start_work` invocation
 
 ## Workflow Steps
 
@@ -103,7 +103,7 @@ Strategic planning workflow that analyzes requirements and creates a structured
 
 ## Integration with Other Workflows
 
-- After plan approval, use `/start-work` to begin execution
+- After plan approval, use `/start_work` to begin execution
 - Or use `/ultrawork` for fully automated execution without stops
 - Plan files persist in `workspace/plans/` for future reference
 

package/workflows/start-work.md

@@ -17,7 +17,7 @@ Execute an approved plan by delegating tasks to appropriate worker agents, track
 
 1. **Load the plan**
    - Read the most recent plan from `workspace/plans/`
-   - Or specify a plan: `/start-work <plan-file>`
+   - Or specify a plan: `/start_work <plan-file>`
    - Verify plan status is "approved"
    - Update plan status to "in-progress"
 
@@ -106,5 +106,5 @@ After each task completion, output:
 ## Integration
 
 - Plans come from `/plan` workflow
-- `/ultrawork` combines `/plan` + `/start-work` automatically
+- `/ultrawork` combines `/plan` + `/start_work` automatically
 - Wisdom notepads persist across sessions for future reference