wave-agent-sdk 0.11.0 → 0.11.1

package/dist/builtin-skills/builtin-skills/loop/parsing.ts

@@ -1,159 +0,0 @@
-export interface ParsedLoop {
-  interval: string;
-  prompt: string;
-  originalInterval?: string;
-  roundedTo?: string;
-}
-
-export function parseLoopInput(
-  input: string,
-  defaultInterval: string = "10m",
-): ParsedLoop {
-  const trimmedInput = input.trim();
-  if (!trimmedInput) {
-    return { interval: defaultInterval, prompt: "" };
-  }
-
-  // 1. Leading token: ^\d+[smhd]$
-  const tokens = trimmedInput.split(/\s+/);
-  if (tokens[0].match(/^\d+[smhd]$/)) {
-    const interval = tokens[0];
-    const prompt = tokens.slice(1).join(" ");
-    return { interval, prompt };
-  }
-
-  // 2. Trailing "every" clause: every <N><unit> or every <N> <unit-word>
-  // Units: s, m, h, d, second(s), minute(s), hour(s), day(s)
-  const everyRegex =
-    /\s+every\s+(\d+)\s*(s|m|h|d|seconds?|minutes?|hours?|days?)$/i;
-  const match = trimmedInput.match(everyRegex);
-  if (match) {
-    const n = match[1];
-    const unitWord = match[2].toLowerCase();
-    const unit = unitWord[0];
-    const interval = `${n}${unit}`;
-    const prompt = trimmedInput.substring(0, match.index).trim();
-    return { interval, prompt };
-  }
-
-  // 3. Default
-  return { interval: defaultInterval, prompt: trimmedInput };
-}
-
-const CLEAN_MINUTES = [1, 2, 3, 4, 5, 6, 10, 12, 15, 20, 30];
-const CLEAN_HOURS = [1, 2, 3, 4, 6, 8, 12];
-
-function getNearestClean(value: number, cleanValues: number[]): number {
-  let nearest = cleanValues[0];
-  let minDiff = Math.abs(value - nearest);
-  for (const clean of cleanValues) {
-    const diff = Math.abs(value - clean);
-    if (diff < minDiff) {
-      minDiff = diff;
-      nearest = clean;
-    } else if (diff === minDiff) {
-      // If equal diff, prefer the larger one? Or smaller?
-      // Let's prefer the larger one to be less frequent
-      if (clean > nearest) {
-        nearest = clean;
-      }
-    }
-  }
-  return nearest;
-}
-
-export function intervalToCron(interval: string): {
-  cron: string;
-  roundedTo?: string;
-  cadence: string;
-} {
-  const match = interval.match(/^(\d+)([smhd])$/);
-  if (!match) {
-    throw new Error(`Invalid interval format: ${interval}`);
-  }
-
-  let n = parseInt(match[1], 10);
-  const unit = match[2];
-  let roundedTo: string | undefined;
-
-  if (unit === "s") {
-    const minutes = Math.ceil(n / 60);
-    const result = intervalToCron(`${minutes}m`);
-    return {
-      ...result,
-      roundedTo:
-        result.roundedTo || (minutes * 60 !== n ? `${minutes}m` : undefined),
-    };
-  }
-
-  if (unit === "m") {
-    if (n >= 60) {
-      const hours = Math.round(n / 60);
-      const result = intervalToCron(`${hours}h`);
-      return {
-        ...result,
-        roundedTo:
-          result.roundedTo || (hours * 60 !== n ? `${hours}h` : undefined),
-      };
-    }
-
-    if (!CLEAN_MINUTES.includes(n)) {
-      const nearest = getNearestClean(n, CLEAN_MINUTES);
-      roundedTo = `${nearest}m`;
-      n = nearest;
-    }
-
-    // For minutes, we use */N. Thundering herd is less of an issue for high frequency,
-    // but we could still offset it. However, the spec says "random minute for approximate requests like 'hourly'".
-    // So for minutes, we'll stick to */N.
-    return {
-      cron: `*/${n} * * * *`,
-      roundedTo,
-      cadence: `every ${n} minute${n > 1 ? "s" : ""}`,
-    };
-  }
-
-  if (unit === "h") {
-    if (n > 23) {
-      const days = Math.round(n / 24);
-      const result = intervalToCron(`${days}d`);
-      return {
-        ...result,
-        roundedTo:
-          result.roundedTo || (days * 24 !== n ? `${days}d` : undefined),
-      };
-    }
-
-    if (!CLEAN_HOURS.includes(n)) {
-      const nearest = getNearestClean(n, CLEAN_HOURS);
-      roundedTo = `${nearest}h`;
-      n = nearest;
-    }
-
-    // Thundering herd prevention: pick a random minute
-    const randomMinute = Math.floor(Math.random() * 60);
-    return {
-      cron: `${randomMinute} */${n} * * *`,
-      roundedTo,
-      cadence: `every ${n} hour${n > 1 ? "s" : ""}`,
-    };
-  }
-
-  if (unit === "d") {
-    if (![1, 2, 3, 4, 5, 6, 7, 10, 14, 30].includes(n)) {
-      // For days, we don't have a strict "clean" list in spec, but let's use some common ones if needed.
-      // Actually, cron supports any */N for days.
-    }
-
-    // Thundering herd prevention: pick a random minute and hour
-    const randomMinute = Math.floor(Math.random() * 60);
-    const randomHour = Math.floor(Math.random() * 24);
-    return {
-      cron: `${randomMinute} ${randomHour} */${n} * *`,
-      roundedTo,
-      cadence: `every ${n} day${n > 1 ? "s" : ""}`,
-    };
-  }
-
-  throw new Error(`Unsupported unit: ${unit}`);
-}

package/dist/builtin-skills/builtin-skills/settings/HOOKS.md

@@ -1,82 +0,0 @@
-# Wave Hooks Configuration
-
-Hooks allow you to automate tasks when certain events occur in Wave. This document provides detailed guidance on how to configure hooks in `settings.json`.
-
-## Hook Events
-
-Wave supports the following hook events:
-
-- `PreToolUse`: Triggered before a tool is executed.
-- `PostToolUse`: Triggered after a tool has finished executing.
-- `UserPromptSubmit`: Triggered when a user submits a prompt.
-- `PermissionRequest`: Triggered when Wave requests permission to use a tool.
-- `Stop`: Triggered when Wave finishes its response cycle (no more tool calls).
-- `SubagentStop`: Triggered when a subagent finishes its response cycle.
-- `WorktreeCreate`: Triggered when a new worktree is created.
-
-## Hook Configuration Structure
-
-Hooks are configured in the `hooks` field of `settings.json`. Each event can have multiple hook configurations.
-
-```json
-{
-  "hooks": {
-    "PreToolUse": [
-      {
-        "matcher": "Write",
-        "hooks": [
-          {
-            "command": "pnpm lint",
-            "description": "Run lint before writing files"
-          }
-        ]
-      }
-    ],
-    "PermissionRequest": [
-      {
-        "matcher": "Bash",
-        "hooks": [
-          {
-            "command": "echo \"Permission requested for Bash tool\" >> hooks.log",
-            "description": "Log permission requests for Bash"
-          }
-        ]
-      }
-    ]
-  }
-}
-```
-
-## Hook Configuration Fields
-
-- `matcher`: (Optional) A pattern to match against the tool name (e.g., "Write", "Read*", "/^Edit/"). Only applicable for `PreToolUse`, `PostToolUse`, and `PermissionRequest`.
-- `hooks`: An array of hook commands to execute.
-  - `command`: The shell command to execute.
-  - `description`: A brief description of the hook's purpose.
-  - `async`: (Optional) Whether the hook should run in the background without blocking (default: `false`).
-  - `timeout`: (Optional) Maximum execution time in seconds (default: `600`).
-
-## Hook Input JSON
-
-Wave provides detailed context to hook processes via `stdin` as a JSON object. This allows hooks to make informed decisions based on the current state.
-
-### Common Fields
-- `session_id`: The current session ID.
-- `transcript_path`: Path to the session transcript file (JSON).
-- `cwd`: The current working directory.
-- `hook_event_name`: The name of the triggering event.
-
-### Event-Specific Fields
-- `tool_name`: (PreToolUse, PostToolUse, PermissionRequest) The name of the tool.
-- `tool_input`: (PreToolUse, PostToolUse, PermissionRequest) The input parameters passed to the tool.
-- `tool_response`: (PostToolUse) The result of the tool execution.
-- `user_prompt`: (UserPromptSubmit) The text submitted by the user.
-- `subagent_type`: (If executed by a subagent) The type of the subagent.
-- `name`: (WorktreeCreate) The name of the new worktree.
-
-## Best Practices
-
-- **Keep hooks fast**: Long-running hooks can slow down your workflow unless they are `async`.
-- **Use descriptive names**: Help yourself and others understand what each hook does.
-- **Test your hooks**: Run the commands manually first to ensure they work as expected.
-- **Use local overrides**: For machine-specific hooks, use `.wave/settings.local.json`.

package/dist/builtin-skills/builtin-skills/settings/SKILL.md

@@ -1,86 +0,0 @@
----
-name: settings
-description: Manage Wave settings and get guidance on settings.json
-allowed-tools: Bash, Read, Write
----
-
-# Wave Settings Skill
-
-This skill helps you manage your Wave configuration and provides guidance on how to use `settings.json`.
-
-## What is `settings.json`?
-
-`settings.json` is the central configuration file for Wave. It allows you to customize hooks, environment variables, tool permissions, and more.
-
-Wave looks for `settings.json` in three scopes:
-1.  **User Scope**: Global settings for all projects. Located at `~/.wave/settings.json`.
-2.  **Project Scope**: Settings specific to the current project. Located at `.wave/settings.json` in your project root.
-3.  **Local Scope**: Local overrides for the current project (not committed to git). Located at `.wave/settings.local.json`.
-
-## Common Settings
-
-### 1. Hooks
-Hooks allow you to automate tasks when certain events occur (e.g., `WorktreeCreate`, `TaskStart`).
-For detailed hook configuration, see [HOOKS.md](${WAVE_SKILL_DIR}/HOOKS.md).
-
-### 2. Environment Variables
-Set environment variables that will be available to all tools and hooks.
-```json
-{
-  "env": {
-    "NODE_ENV": "development",
-    "API_KEY": "your-api-key"
-  }
-}
-```
-
-### 3. Permissions
-Manage tool permissions and define the "Safe Zone".
-```json
-{
-  "permissions": {
-    "allow": ["Bash", "Read"],
-    "deny": ["Write"],
-    "permissionMode": "default",
-    "additionalDirectories": ["/tmp/wave-exports"]
-  }
-}
-```
-
-### 4. Enabled Plugins
-Enable or disable specific plugins.
-```json
-{
-  "enabledPlugins": {
-    "git-plugin": true,
-    "experimental-plugin": false
-  }
-}
-```
-
-### 5. Model and Token Configuration
-Define which AI models Wave should use and set token limits via environment variables.
-```json
-{
-  "env": {
-    "WAVE_MODEL": "gemini-3-flash",
-    "WAVE_FAST_MODEL": "gemini-2.5-flash",
-    "WAVE_MAX_INPUT_TOKENS": "100000",
-    "WAVE_MAX_OUTPUT_TOKENS": "4096"
-  }
-}
-```
-
-### 6. Other Settings
-- `language`: Preferred language for agent communication (e.g., `"en"`, `"zh"`).
-- `autoMemoryEnabled`: Enable or disable auto-memory (default: `true`).
-
-## How to use this skill
-
-You can ask me to:
-- "Show my current settings"
-- "Update my project settings to enable auto-memory"
-- "How do I configure a post-commit hook?"
-- "What are the available permission modes?"
-
-I will guide you through the process and ensure your configuration is valid.

package/dist/builtin-skills/loop/parsing.d.ts

@@ -1,13 +0,0 @@
-export interface ParsedLoop {
-    interval: string;
-    prompt: string;
-    originalInterval?: string;
-    roundedTo?: string;
-}
-export declare function parseLoopInput(input: string, defaultInterval?: string): ParsedLoop;
-export declare function intervalToCron(interval: string): {
-    cron: string;
-    roundedTo?: string;
-    cadence: string;
-};
-//# sourceMappingURL=parsing.d.ts.map

package/dist/builtin-skills/loop/parsing.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parsing.d.ts","sourceRoot":"","sources":["../../../src/builtin-skills/loop/parsing.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,UAAU;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,EACb,eAAe,GAAE,MAAc,GAC9B,UAAU,CA8BZ;AAwBD,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG;IAChD,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACjB,CA0FA"}

package/dist/builtin-skills/loop/parsing.js

@@ -1,125 +0,0 @@
-export function parseLoopInput(input, defaultInterval = "10m") {
-    const trimmedInput = input.trim();
-    if (!trimmedInput) {
-        return { interval: defaultInterval, prompt: "" };
-    }
-    // 1. Leading token: ^\d+[smhd]$
-    const tokens = trimmedInput.split(/\s+/);
-    if (tokens[0].match(/^\d+[smhd]$/)) {
-        const interval = tokens[0];
-        const prompt = tokens.slice(1).join(" ");
-        return { interval, prompt };
-    }
-    // 2. Trailing "every" clause: every <N><unit> or every <N> <unit-word>
-    // Units: s, m, h, d, second(s), minute(s), hour(s), day(s)
-    const everyRegex = /\s+every\s+(\d+)\s*(s|m|h|d|seconds?|minutes?|hours?|days?)$/i;
-    const match = trimmedInput.match(everyRegex);
-    if (match) {
-        const n = match[1];
-        const unitWord = match[2].toLowerCase();
-        const unit = unitWord[0];
-        const interval = `${n}${unit}`;
-        const prompt = trimmedInput.substring(0, match.index).trim();
-        return { interval, prompt };
-    }
-    // 3. Default
-    return { interval: defaultInterval, prompt: trimmedInput };
-}
-const CLEAN_MINUTES = [1, 2, 3, 4, 5, 6, 10, 12, 15, 20, 30];
-const CLEAN_HOURS = [1, 2, 3, 4, 6, 8, 12];
-function getNearestClean(value, cleanValues) {
-    let nearest = cleanValues[0];
-    let minDiff = Math.abs(value - nearest);
-    for (const clean of cleanValues) {
-        const diff = Math.abs(value - clean);
-        if (diff < minDiff) {
-            minDiff = diff;
-            nearest = clean;
-        }
-        else if (diff === minDiff) {
-            // If equal diff, prefer the larger one? Or smaller?
-            // Let's prefer the larger one to be less frequent
-            if (clean > nearest) {
-                nearest = clean;
-            }
-        }
-    }
-    return nearest;
-}
-export function intervalToCron(interval) {
-    const match = interval.match(/^(\d+)([smhd])$/);
-    if (!match) {
-        throw new Error(`Invalid interval format: ${interval}`);
-    }
-    let n = parseInt(match[1], 10);
-    const unit = match[2];
-    let roundedTo;
-    if (unit === "s") {
-        const minutes = Math.ceil(n / 60);
-        const result = intervalToCron(`${minutes}m`);
-        return {
-            ...result,
-            roundedTo: result.roundedTo || (minutes * 60 !== n ? `${minutes}m` : undefined),
-        };
-    }
-    if (unit === "m") {
-        if (n >= 60) {
-            const hours = Math.round(n / 60);
-            const result = intervalToCron(`${hours}h`);
-            return {
-                ...result,
-                roundedTo: result.roundedTo || (hours * 60 !== n ? `${hours}h` : undefined),
-            };
-        }
-        if (!CLEAN_MINUTES.includes(n)) {
-            const nearest = getNearestClean(n, CLEAN_MINUTES);
-            roundedTo = `${nearest}m`;
-            n = nearest;
-        }
-        // For minutes, we use */N. Thundering herd is less of an issue for high frequency,
-        // but we could still offset it. However, the spec says "random minute for approximate requests like 'hourly'".
-        // So for minutes, we'll stick to */N.
-        return {
-            cron: `*/${n} * * * *`,
-            roundedTo,
-            cadence: `every ${n} minute${n > 1 ? "s" : ""}`,
-        };
-    }
-    if (unit === "h") {
-        if (n > 23) {
-            const days = Math.round(n / 24);
-            const result = intervalToCron(`${days}d`);
-            return {
-                ...result,
-                roundedTo: result.roundedTo || (days * 24 !== n ? `${days}d` : undefined),
-            };
-        }
-        if (!CLEAN_HOURS.includes(n)) {
-            const nearest = getNearestClean(n, CLEAN_HOURS);
-            roundedTo = `${nearest}h`;
-            n = nearest;
-        }
-        // Thundering herd prevention: pick a random minute
-        const randomMinute = Math.floor(Math.random() * 60);
-        return {
-            cron: `${randomMinute} */${n} * * *`,
-            roundedTo,
-            cadence: `every ${n} hour${n > 1 ? "s" : ""}`,
-        };
-    }
-    if (unit === "d") {
-        if (![1, 2, 3, 4, 5, 6, 7, 10, 14, 30].includes(n)) {
-            // For days, we don't have a strict "clean" list in spec, but let's use some common ones if needed.
-            // Actually, cron supports any */N for days.
-        }
-        // Thundering herd prevention: pick a random minute and hour
-        const randomMinute = Math.floor(Math.random() * 60);
-        const randomHour = Math.floor(Math.random() * 24);
-        return {
-            cron: `${randomMinute} ${randomHour} */${n} * *`,
-            roundedTo,
-            cadence: `every ${n} day${n > 1 ? "s" : ""}`,
-        };
-    }
-    throw new Error(`Unsupported unit: ${unit}`);
-}

package/dist/utils/builtinSubagents.d.ts

@@ -1,7 +0,0 @@
-import type { SubagentConfiguration } from "./subagentParser.js";
-/**
- * Get all built-in subagent configurations
- * Built-in subagents have priority 3 (lowest) and can be overridden by user/project configs
- */
-export declare function getBuiltinSubagents(): SubagentConfiguration[];
-//# sourceMappingURL=builtinSubagents.d.ts.map

package/dist/utils/builtinSubagents.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"builtinSubagents.d.ts","sourceRoot":"","sources":["../../src/utils/builtinSubagents.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAEjE;;;GAGG;AACH,wBAAgB,mBAAmB,IAAI,qBAAqB,EAAE,CAQ7D"}

package/dist/utils/builtinSubagents.js

@@ -1,94 +0,0 @@
-import { BASH_SUBAGENT_TYPE, EXPLORE_SUBAGENT_TYPE, PLAN_SUBAGENT_TYPE, GENERAL_PURPOSE_SUBAGENT_TYPE, } from "../constants/subagents.js";
-import { BASH_SUBAGENT_SYSTEM_PROMPT, GENERAL_PURPOSE_SYSTEM_PROMPT, PLAN_SUBAGENT_SYSTEM_PROMPT, EXPLORE_SUBAGENT_SYSTEM_PROMPT, } from "../prompts/index.js";
-import { BASH_TOOL_NAME, GLOB_TOOL_NAME, GREP_TOOL_NAME, READ_TOOL_NAME, LSP_TOOL_NAME, } from "../constants/tools.js";
-/**
- * Get all built-in subagent configurations
- * Built-in subagents have priority 3 (lowest) and can be overridden by user/project configs
- */
-export function getBuiltinSubagents() {
-    return [
-        createBashSubagent(),
-        createExploreSubagent(),
-        createGeneralPurposeSubagent(),
-        createPlanSubagent(),
-        // Add more built-in subagents here as needed
-    ];
-}
-/**
- * Create the Bash built-in subagent configuration
- * Specialized for executing bash commands and git operations
- */
-function createBashSubagent() {
-    return {
-        name: BASH_SUBAGENT_TYPE,
-        description: "Command execution specialist for running bash commands. Use this for git operations, command execution, and other terminal tasks.",
-        systemPrompt: BASH_SUBAGENT_SYSTEM_PROMPT,
-        tools: [BASH_TOOL_NAME],
-        model: "inherit",
-        filePath: `<builtin:${BASH_SUBAGENT_TYPE}>`,
-        scope: "builtin",
-        priority: 3,
-    };
-}
-/**
- * Create the General-Purpose built-in subagent configuration
- * Specialized for multi-step research and implementation tasks
- */
-function createGeneralPurposeSubagent() {
-    return {
-        name: GENERAL_PURPOSE_SUBAGENT_TYPE,
-        description: "General-purpose agent for researching complex questions, searching for code, and executing multi-step tasks. When you are searching for a keyword or file and are not confident that you will find the right match in the first few tries use this agent to perform the search for you.",
-        systemPrompt: GENERAL_PURPOSE_SYSTEM_PROMPT,
-        filePath: `<builtin:${GENERAL_PURPOSE_SUBAGENT_TYPE}>`,
-        scope: "builtin",
-        priority: 3,
-    };
-}
-/**
- * Create the Explore built-in subagent configuration
- * Specialized for codebase exploration and file search tasks
- */
-function createExploreSubagent() {
-    // Define allowed tools for read-only operations
-    const allowedTools = [
-        GLOB_TOOL_NAME,
-        GREP_TOOL_NAME,
-        READ_TOOL_NAME,
-        BASH_TOOL_NAME,
-        LSP_TOOL_NAME,
-    ];
-    return {
-        name: EXPLORE_SUBAGENT_TYPE,
-        description: 'Fast agent specialized for exploring codebases. Use this when you need to quickly find files by patterns (eg. "src/components/**/*.tsx"), search code for keywords (eg. "API endpoints"), or answer questions about the codebase (eg. "how do API endpoints work?"). When calling this agent, specify the desired thoroughness level: "quick" for basic searches, "medium" for moderate exploration, or "very thorough" for comprehensive analysis across multiple locations and naming conventions.',
-        systemPrompt: EXPLORE_SUBAGENT_SYSTEM_PROMPT,
-        tools: allowedTools,
-        model: "fastModel", // Special value that will use parent's fastModel
-        filePath: `<builtin:${EXPLORE_SUBAGENT_TYPE}>`,
-        scope: "builtin",
-        priority: 3, // Lowest priority - can be overridden by user configs
-    };
-}
-/**
- * Create the Plan built-in subagent configuration
- * Specialized for designing implementation plans and exploring codebases in read-only mode
- */
-function createPlanSubagent() {
-    // Define allowed tools for read-only operations
-    const allowedTools = [
-        GLOB_TOOL_NAME,
-        GREP_TOOL_NAME,
-        READ_TOOL_NAME,
-        BASH_TOOL_NAME,
-        LSP_TOOL_NAME,
-    ];
-    return {
-        name: PLAN_SUBAGENT_TYPE,
-        description: "Software architect agent for designing implementation plans. Use this when you need to plan the implementation strategy for a task. Returns step-by-step plans, identifies critical files, and considers architectural trade-offs.",
-        systemPrompt: PLAN_SUBAGENT_SYSTEM_PROMPT,
-        tools: allowedTools,
-        model: "inherit", // Uses parent agent's model
-        filePath: `<builtin:${PLAN_SUBAGENT_TYPE}>`,
-        scope: "builtin",
-        priority: 3, // Lowest priority - can be overridden by user configs
-    };
-}

package/src/builtin-skills/loop/SKILL.md

@@ -1,53 +0,0 @@
----
-name: loop
-description: Parses user input into an interval and prompt, converts the interval to a cron expression, and schedules a recurring task
-allowed-tools: CronCreate, Skill
----
-# /loop — schedule a recurring prompt
-
-Parse the input below into `[interval] <prompt…>` and schedule it with CronCreate.
-
-## Parsing (in priority order)
-
-1. **Leading token**: if the first whitespace-delimited token matches `^\d+[smhd]$` (e.g. `5m`, `2h`), that's the interval; the rest is the prompt.
-2. **Trailing "every" clause**: otherwise, if the input ends with `every <N><unit>` or `every <N> <unit-word>` (e.g. `every 20m`, `every 5 minutes`, `every 2 hours`), extract that as the interval and strip it from the prompt. Only match when what follows "every" is a time expression — `check every PR` has no interval.
-3. **Default**: otherwise, interval is `10m` and the entire input is the prompt.
-
-If the resulting prompt is empty, show usage `/loop [interval] <prompt>` and stop — do not call CronCreate.
-
-Examples:
-- `5m /babysit-prs` → interval `5m`, prompt `/babysit-prs` (rule 1)
-- `check the deploy every 20m` → interval `20m`, prompt `check the deploy` (rule 2)
-- `run tests every 5 minutes` → interval `5m`, prompt `run tests` (rule 2)
-- `check the deploy` → interval `10m`, prompt `check the deploy` (rule 3)
-- `check every PR` → interval `10m`, prompt `check every PR` (rule 3 — "every" not followed by time)
-- `5m` → empty prompt → show usage
-
-## Interval → cron
-
-Supported suffixes: `s` (seconds, rounded up to nearest minute, min 1), `m` (minutes), `h` (hours), `d` (days). Convert:
-
-| Interval pattern      | Cron expression     | Notes                                    |
-|-----------------------|---------------------|------------------------------------------|
-| `Nm` where N ≤ 59   | `*/N * * * *`     | every N minutes                          |
-| `Nm` where N ≥ 60   | `0 */H * * *`     | round to hours (H = N/60, must divide 24)|
-| `Nh` where N ≤ 23   | `0 */N * * *`     | every N hours                            |
-| `Nd`                | `0 0 */N * *`     | every N days at midnight local           |
-| `Ns`                | treat as `ceil(N/60)m` | cron minimum granularity is 1 minute  |
-
-**If the interval doesn't cleanly divide its unit** (e.g. `7m` → `*/7 * * * *` gives uneven gaps at :56→:00; `90m` → 1.5h which cron can't express), pick the nearest clean interval and tell the user what you rounded to before scheduling.
-
-**Thundering herd prevention**: For approximate requests like "hourly" or "every morning", pick a random minute (e.g., 7) instead of 0 to avoid global sync issues.
-
-## Action
-
-1. Call CronCreate with:
-   - `cron`: the expression from the table above
-   - `prompt`: the parsed prompt from above, verbatim (slash commands are passed through unchanged)
-   - `recurring`: `true`
-2. Briefly confirm: what's scheduled, the cron expression, the human-readable cadence, that recurring tasks auto-expire after 7 days, and that they can cancel sooner with CronDelete (include the job ID).
-3. **Then immediately execute the parsed prompt now** — don't wait for the first cron fire. If it's a slash command, invoke it via the Skill tool; otherwise act on it directly.
-
-## Input
-
-$ARGUMENTS