yzcode-cli 1.0.2 → 1.0.3

package/skills/bundled/claudeInChrome.ts

@@ -0,0 +1,34 @@
+import { BROWSER_TOOLS } from '@ant/claude-for-chrome-mcp'
+import { BASE_CHROME_PROMPT } from '../../utils/claudeInChrome/prompt.js'
+import { shouldAutoEnableClaudeInChrome } from '../../utils/claudeInChrome/setup.js'
+import { registerBundledSkill } from '../bundledSkills.js'
+
+const CLAUDE_IN_CHROME_MCP_TOOLS = BROWSER_TOOLS.map(
+  tool => `mcp__claude-in-chrome__${tool.name}`,
+)
+
+const SKILL_ACTIVATION_MESSAGE = `
+Now that this skill is invoked, you have access to Chrome browser automation tools. You can now use the mcp__claude-in-chrome__* tools to interact with web pages.
+
+IMPORTANT: Start by calling mcp__claude-in-chrome__tabs_context_mcp to get information about the user's current browser tabs.
+`
+
+export function registerClaudeInChromeSkill(): void {
+  registerBundledSkill({
+    name: 'claude-in-chrome',
+    description:
+      'Automates your Chrome browser to interact with web pages - clicking elements, filling forms, capturing screenshots, reading console logs, and navigating sites. Opens pages in new tabs within your existing Chrome session. Requires site-level permissions before executing (configured in the extension).',
+    whenToUse:
+      'When the user wants to interact with web pages, automate browser tasks, capture screenshots, read console logs, or perform any browser-based actions. Always invoke BEFORE attempting to use any mcp__claude-in-chrome__* tools.',
+    allowedTools: CLAUDE_IN_CHROME_MCP_TOOLS,
+    userInvocable: true,
+    isEnabled: () => shouldAutoEnableClaudeInChrome(),
+    async getPromptForCommand(args) {
+      let prompt = `${BASE_CHROME_PROMPT}\n${SKILL_ACTIVATION_MESSAGE}`
+      if (args) {
+        prompt += `\n## Task\n\n${args}`
+      }
+      return [{ type: 'text', text: prompt }]
+    },
+  })
+}

package/skills/bundled/debug.ts

@@ -0,0 +1,103 @@
+import { open, stat } from 'fs/promises'
+import { CLAUDE_CODE_GUIDE_AGENT_TYPE } from 'src/tools/AgentTool/built-in/claudeCodeGuideAgent.js'
+import { getSettingsFilePathForSource } from 'src/utils/settings/settings.js'
+import { enableDebugLogging, getDebugLogPath } from '../../utils/debug.js'
+import { errorMessage, isENOENT } from '../../utils/errors.js'
+import { formatFileSize } from '../../utils/format.js'
+import { registerBundledSkill } from '../bundledSkills.js'
+
+const DEFAULT_DEBUG_LINES_READ = 20
+const TAIL_READ_BYTES = 64 * 1024
+
+export function registerDebugSkill(): void {
+  registerBundledSkill({
+    name: 'debug',
+    description:
+      process.env.USER_TYPE === 'ant'
+        ? 'Debug your current Claude Code session by reading the session debug log. Includes all event logging'
+        : 'Enable debug logging for this session and help diagnose issues',
+    allowedTools: ['Read', 'Grep', 'Glob'],
+    argumentHint: '[issue description]',
+    // disableModelInvocation so that the user has to explicitly request it in
+    // interactive mode and so the description does not take up context.
+    disableModelInvocation: true,
+    userInvocable: true,
+    async getPromptForCommand(args) {
+      // Non-ants don't write debug logs by default — turn logging on now so
+      // subsequent activity in this session is captured.
+      const wasAlreadyLogging = enableDebugLogging()
+      const debugLogPath = getDebugLogPath()
+
+      let logInfo: string
+      try {
+        // Tail the log without reading the whole thing - debug logs grow
+        // unbounded in long sessions and reading them in full spikes RSS.
+        const stats = await stat(debugLogPath)
+        const readSize = Math.min(stats.size, TAIL_READ_BYTES)
+        const startOffset = stats.size - readSize
+        const fd = await open(debugLogPath, 'r')
+        try {
+          const { buffer, bytesRead } = await fd.read({
+            buffer: Buffer.alloc(readSize),
+            position: startOffset,
+          })
+          const tail = buffer
+            .toString('utf-8', 0, bytesRead)
+            .split('\n')
+            .slice(-DEFAULT_DEBUG_LINES_READ)
+            .join('\n')
+          logInfo = `Log size: ${formatFileSize(stats.size)}\n\n### Last ${DEFAULT_DEBUG_LINES_READ} lines\n\n\`\`\`\n${tail}\n\`\`\``
+        } finally {
+          await fd.close()
+        }
+      } catch (e) {
+        logInfo = isENOENT(e)
+          ? 'No debug log exists yet — logging was just enabled.'
+          : `Failed to read last ${DEFAULT_DEBUG_LINES_READ} lines of debug log: ${errorMessage(e)}`
+      }
+
+      const justEnabledSection = wasAlreadyLogging
+        ? ''
+        : `
+## Debug Logging Just Enabled
+
+Debug logging was OFF for this session until now. Nothing prior to this /debug invocation was captured.
+
+Tell the user that debug logging is now active at \`${debugLogPath}\`, ask them to reproduce the issue, then re-read the log. If they can't reproduce, they can also restart with \`claude --debug\` to capture logs from startup.
+`
+
+      const prompt = `# Debug Skill
+
+Help the user debug an issue they're encountering in this current Claude Code session.
+${justEnabledSection}
+## Session Debug Log
+
+The debug log for the current session is at: \`${debugLogPath}\`
+
+${logInfo}
+
+For additional context, grep for [ERROR] and [WARN] lines across the full file.
+
+## Issue Description
+
+${args || 'The user did not describe a specific issue. Read the debug log and summarize any errors, warnings, or notable issues.'}
+
+## Settings
+
+Remember that settings are in:
+* user - ${getSettingsFilePathForSource('userSettings')}
+* project - ${getSettingsFilePathForSource('projectSettings')}
+* local - ${getSettingsFilePathForSource('localSettings')}
+
+## Instructions
+
+1. Review the user's issue description
+2. The last ${DEFAULT_DEBUG_LINES_READ} lines show the debug file format. Look for [ERROR] and [WARN] entries, stack traces, and failure patterns across the file
+3. Consider launching the ${CLAUDE_CODE_GUIDE_AGENT_TYPE} subagent to understand the relevant Claude Code features
+4. Explain what you found in plain language
+5. Suggest concrete fixes or next steps
+`
+      return [{ type: 'text', text: prompt }]
+    },
+  })
+}

package/skills/bundled/index.ts

@@ -0,0 +1,79 @@
+import { feature } from 'bun:bundle'
+import { shouldAutoEnableClaudeInChrome } from 'src/utils/claudeInChrome/setup.js'
+import { registerBatchSkill } from './batch.js'
+import { registerClaudeInChromeSkill } from './claudeInChrome.js'
+import { registerDebugSkill } from './debug.js'
+import { registerKeybindingsSkill } from './keybindings.js'
+import { registerLoremIpsumSkill } from './loremIpsum.js'
+import { registerRememberSkill } from './remember.js'
+import { registerSimplifySkill } from './simplify.js'
+import { registerSkillifySkill } from './skillify.js'
+import { registerStuckSkill } from './stuck.js'
+import { registerUpdateConfigSkill } from './updateConfig.js'
+import { registerVerifySkill } from './verify.js'
+
+/**
+ * Initialize all bundled skills.
+ * Called at startup to register skills that ship with the CLI.
+ *
+ * To add a new bundled skill:
+ * 1. Create a new file in src/skills/bundled/ (e.g., myskill.ts)
+ * 2. Export a register function that calls registerBundledSkill()
+ * 3. Import and call that function here
+ */
+export function initBundledSkills(): void {
+  registerUpdateConfigSkill()
+  registerKeybindingsSkill()
+  registerVerifySkill()
+  registerDebugSkill()
+  registerLoremIpsumSkill()
+  registerSkillifySkill()
+  registerRememberSkill()
+  registerSimplifySkill()
+  registerBatchSkill()
+  registerStuckSkill()
+  if (feature('KAIROS') || feature('KAIROS_DREAM')) {
+    /* eslint-disable @typescript-eslint/no-require-imports */
+    const { registerDreamSkill } = require('./dream.js')
+    /* eslint-enable @typescript-eslint/no-require-imports */
+    registerDreamSkill()
+  }
+  if (feature('REVIEW_ARTIFACT')) {
+    /* eslint-disable @typescript-eslint/no-require-imports */
+    const { registerHunterSkill } = require('./hunter.js')
+    /* eslint-enable @typescript-eslint/no-require-imports */
+    registerHunterSkill()
+  }
+  if (feature('AGENT_TRIGGERS')) {
+    /* eslint-disable @typescript-eslint/no-require-imports */
+    const { registerLoopSkill } = require('./loop.js')
+    /* eslint-enable @typescript-eslint/no-require-imports */
+    // /loop's isEnabled delegates to isKairosCronEnabled() — same lazy
+    // per-invocation pattern as the cron tools. Registered unconditionally;
+    // the skill's own isEnabled callback decides visibility.
+    registerLoopSkill()
+  }
+  if (feature('AGENT_TRIGGERS_REMOTE')) {
+    /* eslint-disable @typescript-eslint/no-require-imports */
+    const {
+      registerScheduleRemoteAgentsSkill,
+    } = require('./scheduleRemoteAgents.js')
+    /* eslint-enable @typescript-eslint/no-require-imports */
+    registerScheduleRemoteAgentsSkill()
+  }
+  if (feature('BUILDING_CLAUDE_APPS')) {
+    /* eslint-disable @typescript-eslint/no-require-imports */
+    const { registerClaudeApiSkill } = require('./claudeApi.js')
+    /* eslint-enable @typescript-eslint/no-require-imports */
+    registerClaudeApiSkill()
+  }
+  if (shouldAutoEnableClaudeInChrome()) {
+    registerClaudeInChromeSkill()
+  }
+  if (feature('RUN_SKILL_GENERATOR')) {
+    /* eslint-disable @typescript-eslint/no-require-imports */
+    const { registerRunSkillGeneratorSkill } = require('./runSkillGenerator.js')
+    /* eslint-enable @typescript-eslint/no-require-imports */
+    registerRunSkillGeneratorSkill()
+  }
+}

package/skills/bundled/keybindings.ts

@@ -0,0 +1,339 @@
+import { DEFAULT_BINDINGS } from '../../keybindings/defaultBindings.js'
+import { isKeybindingCustomizationEnabled } from '../../keybindings/loadUserBindings.js'
+import {
+  MACOS_RESERVED,
+  NON_REBINDABLE,
+  TERMINAL_RESERVED,
+} from '../../keybindings/reservedShortcuts.js'
+import type { KeybindingsSchemaType } from '../../keybindings/schema.js'
+import {
+  KEYBINDING_ACTIONS,
+  KEYBINDING_CONTEXT_DESCRIPTIONS,
+  KEYBINDING_CONTEXTS,
+} from '../../keybindings/schema.js'
+import { jsonStringify } from '../../utils/slowOperations.js'
+import { registerBundledSkill } from '../bundledSkills.js'
+
+/**
+ * Build a markdown table of all contexts.
+ */
+function generateContextsTable(): string {
+  return markdownTable(
+    ['Context', 'Description'],
+    KEYBINDING_CONTEXTS.map(ctx => [
+      `\`${ctx}\``,
+      KEYBINDING_CONTEXT_DESCRIPTIONS[ctx],
+    ]),
+  )
+}
+
+/**
+ * Build a markdown table of all actions with their default bindings and context.
+ */
+function generateActionsTable(): string {
+  // Build a lookup: action -> { keys, context }
+  const actionInfo: Record<string, { keys: string[]; context: string }> = {}
+  for (const block of DEFAULT_BINDINGS) {
+    for (const [key, action] of Object.entries(block.bindings)) {
+      if (action) {
+        if (!actionInfo[action]) {
+          actionInfo[action] = { keys: [], context: block.context }
+        }
+        actionInfo[action].keys.push(key)
+      }
+    }
+  }
+
+  return markdownTable(
+    ['Action', 'Default Key(s)', 'Context'],
+    KEYBINDING_ACTIONS.map(action => {
+      const info = actionInfo[action]
+      const keys = info ? info.keys.map(k => `\`${k}\``).join(', ') : '(none)'
+      const context = info ? info.context : inferContextFromAction(action)
+      return [`\`${action}\``, keys, context]
+    }),
+  )
+}
+
+/**
+ * Infer context from action prefix when not in DEFAULT_BINDINGS.
+ */
+function inferContextFromAction(action: string): string {
+  const prefix = action.split(':')[0]
+  const prefixToContext: Record<string, string> = {
+    app: 'Global',
+    history: 'Global or Chat',
+    chat: 'Chat',
+    autocomplete: 'Autocomplete',
+    confirm: 'Confirmation',
+    tabs: 'Tabs',
+    transcript: 'Transcript',
+    historySearch: 'HistorySearch',
+    task: 'Task',
+    theme: 'ThemePicker',
+    help: 'Help',
+    attachments: 'Attachments',
+    footer: 'Footer',
+    messageSelector: 'MessageSelector',
+    diff: 'DiffDialog',
+    modelPicker: 'ModelPicker',
+    select: 'Select',
+    permission: 'Confirmation',
+  }
+  return prefixToContext[prefix ?? ''] ?? 'Unknown'
+}
+
+/**
+ * Build a list of reserved shortcuts.
+ */
+function generateReservedShortcuts(): string {
+  const lines: string[] = []
+
+  lines.push('### Non-rebindable (errors)')
+  for (const s of NON_REBINDABLE) {
+    lines.push(`- \`${s.key}\` — ${s.reason}`)
+  }
+
+  lines.push('')
+  lines.push('### Terminal reserved (errors/warnings)')
+  for (const s of TERMINAL_RESERVED) {
+    lines.push(
+      `- \`${s.key}\` — ${s.reason} (${s.severity === 'error' ? 'will not work' : 'may conflict'})`,
+    )
+  }
+
+  lines.push('')
+  lines.push('### macOS reserved (errors)')
+  for (const s of MACOS_RESERVED) {
+    lines.push(`- \`${s.key}\` — ${s.reason}`)
+  }
+
+  return lines.join('\n')
+}
+
+const FILE_FORMAT_EXAMPLE: KeybindingsSchemaType = {
+  $schema: 'https://www.schemastore.org/claude-code-keybindings.json',
+  $docs: 'https://code.claude.com/docs/en/keybindings',
+  bindings: [
+    {
+      context: 'Chat',
+      bindings: {
+        'ctrl+e': 'chat:externalEditor',
+      },
+    },
+  ],
+}
+
+const UNBIND_EXAMPLE: KeybindingsSchemaType['bindings'][number] = {
+  context: 'Chat',
+  bindings: {
+    'ctrl+s': null,
+  },
+}
+
+const REBIND_EXAMPLE: KeybindingsSchemaType['bindings'][number] = {
+  context: 'Chat',
+  bindings: {
+    'ctrl+g': null,
+    'ctrl+e': 'chat:externalEditor',
+  },
+}
+
+const CHORD_EXAMPLE: KeybindingsSchemaType['bindings'][number] = {
+  context: 'Global',
+  bindings: {
+    'ctrl+k ctrl+t': 'app:toggleTodos',
+  },
+}
+
+const SECTION_INTRO = [
+  '# Keybindings Skill',
+  '',
+  'Create or modify `~/.claude/keybindings.json` to customize keyboard shortcuts.',
+  '',
+  '## CRITICAL: Read Before Write',
+  '',
+  '**Always read `~/.claude/keybindings.json` first** (it may not exist yet). Merge changes with existing bindings — never replace the entire file.',
+  '',
+  '- Use **Edit** tool for modifications to existing files',
+  '- Use **Write** tool only if the file does not exist yet',
+].join('\n')
+
+const SECTION_FILE_FORMAT = [
+  '## File Format',
+  '',
+  '```json',
+  jsonStringify(FILE_FORMAT_EXAMPLE, null, 2),
+  '```',
+  '',
+  'Always include the `$schema` and `$docs` fields.',
+].join('\n')
+
+const SECTION_KEYSTROKE_SYNTAX = [
+  '## Keystroke Syntax',
+  '',
+  '**Modifiers** (combine with `+`):',
+  '- `ctrl` (alias: `control`)',
+  '- `alt` (aliases: `opt`, `option`) — note: `alt` and `meta` are identical in terminals',
+  '- `shift`',
+  '- `meta` (aliases: `cmd`, `command`)',
+  '',
+  '**Special keys**: `escape`/`esc`, `enter`/`return`, `tab`, `space`, `backspace`, `delete`, `up`, `down`, `left`, `right`',
+  '',
+  '**Chords**: Space-separated keystrokes, e.g. `ctrl+k ctrl+s` (1-second timeout between keystrokes)',
+  '',
+  '**Examples**: `ctrl+shift+p`, `alt+enter`, `ctrl+k ctrl+n`',
+].join('\n')
+
+const SECTION_UNBINDING = [
+  '## Unbinding Default Shortcuts',
+  '',
+  'Set a key to `null` to remove its default binding:',
+  '',
+  '```json',
+  jsonStringify(UNBIND_EXAMPLE, null, 2),
+  '```',
+].join('\n')
+
+const SECTION_INTERACTION = [
+  '## How User Bindings Interact with Defaults',
+  '',
+  '- User bindings are **additive** — they are appended after the default bindings',
+  '- To **move** a binding to a different key: unbind the old key (`null`) AND add the new binding',
+  "- A context only needs to appear in the user's file if they want to change something in that context",
+].join('\n')
+
+const SECTION_COMMON_PATTERNS = [
+  '## Common Patterns',
+  '',
+  '### Rebind a key',
+  'To change the external editor shortcut from `ctrl+g` to `ctrl+e`:',
+  '```json',
+  jsonStringify(REBIND_EXAMPLE, null, 2),
+  '```',
+  '',
+  '### Add a chord binding',
+  '```json',
+  jsonStringify(CHORD_EXAMPLE, null, 2),
+  '```',
+].join('\n')
+
+const SECTION_BEHAVIORAL_RULES = [
+  '## Behavioral Rules',
+  '',
+  '1. Only include contexts the user wants to change (minimal overrides)',
+  '2. Validate that actions and contexts are from the known lists below',
+  '3. Warn the user proactively if they choose a key that conflicts with reserved shortcuts or common tools like tmux (`ctrl+b`) and screen (`ctrl+a`)',
+  '4. When adding a new binding for an existing action, the new binding is additive (existing default still works unless explicitly unbound)',
+  '5. To fully replace a default binding, unbind the old key AND add the new one',
+].join('\n')
+
+const SECTION_DOCTOR = [
+  '## Validation with /doctor',
+  '',
+  'The `/doctor` command includes a "Keybinding Configuration Issues" section that validates `~/.claude/keybindings.json`.',
+  '',
+  '### Common Issues and Fixes',
+  '',
+  markdownTable(
+    ['Issue', 'Cause', 'Fix'],
+    [
+      [
+        '`keybindings.json must have a "bindings" array`',
+        'Missing wrapper object',
+        'Wrap bindings in `{ "bindings": [...] }`',
+      ],
+      [
+        '`"bindings" must be an array`',
+        '`bindings` is not an array',
+        'Set `"bindings"` to an array: `[{ context: ..., bindings: ... }]`',
+      ],
+      [
+        '`Unknown context "X"`',
+        'Typo or invalid context name',
+        'Use exact context names from the Available Contexts table',
+      ],
+      [
+        '`Duplicate key "X" in Y bindings`',
+        'Same key defined twice in one context',
+        'Remove the duplicate; JSON uses only the last value',
+      ],
+      [
+        '`"X" may not work: ...`',
+        'Key conflicts with terminal/OS reserved shortcut',
+        'Choose a different key (see Reserved Shortcuts section)',
+      ],
+      [
+        '`Could not parse keystroke "X"`',
+        'Invalid key syntax',
+        'Check syntax: use `+` between modifiers, valid key names',
+      ],
+      [
+        '`Invalid action for "X"`',
+        'Action value is not a string or null',
+        'Actions must be strings like `"app:help"` or `null` to unbind',
+      ],
+    ],
+  ),
+  '',
+  '### Example /doctor Output',
+  '',
+  '```',
+  'Keybinding Configuration Issues',
+  'Location: ~/.claude/keybindings.json',
+  '  └ [Error] Unknown context "chat"',
+  '    → Valid contexts: Global, Chat, Autocomplete, ...',
+  '  └ [Warning] "ctrl+c" may not work: Terminal interrupt (SIGINT)',
+  '```',
+  '',
+  '**Errors** prevent bindings from working and must be fixed. **Warnings** indicate potential conflicts but the binding may still work.',
+].join('\n')
+
+export function registerKeybindingsSkill(): void {
+  registerBundledSkill({
+    name: 'keybindings-help',
+    description:
+      'Use when the user wants to customize keyboard shortcuts, rebind keys, add chord bindings, or modify ~/.claude/keybindings.json. Examples: "rebind ctrl+s", "add a chord shortcut", "change the submit key", "customize keybindings".',
+    allowedTools: ['Read'],
+    userInvocable: false,
+    isEnabled: isKeybindingCustomizationEnabled,
+    async getPromptForCommand(args) {
+      // Generate reference tables dynamically from source-of-truth arrays
+      const contextsTable = generateContextsTable()
+      const actionsTable = generateActionsTable()
+      const reservedShortcuts = generateReservedShortcuts()
+
+      const sections = [
+        SECTION_INTRO,
+        SECTION_FILE_FORMAT,
+        SECTION_KEYSTROKE_SYNTAX,
+        SECTION_UNBINDING,
+        SECTION_INTERACTION,
+        SECTION_COMMON_PATTERNS,
+        SECTION_BEHAVIORAL_RULES,
+        SECTION_DOCTOR,
+        `## Reserved Shortcuts\n\n${reservedShortcuts}`,
+        `## Available Contexts\n\n${contextsTable}`,
+        `## Available Actions\n\n${actionsTable}`,
+      ]
+
+      if (args) {
+        sections.push(`## User Request\n\n${args}`)
+      }
+
+      return [{ type: 'text', text: sections.join('\n\n') }]
+    },
+  })
+}
+
+/**
+ * Build a markdown table from headers and rows.
+ */
+function markdownTable(headers: string[], rows: string[][]): string {
+  const separator = headers.map(() => '---')
+  return [
+    `| ${headers.join(' | ')} |`,
+    `| ${separator.join(' | ')} |`,
+    ...rows.map(row => `| ${row.join(' | ')} |`),
+  ].join('\n')
+}

package/skills/bundled/loop.ts

@@ -0,0 +1,92 @@
+import {
+  CRON_CREATE_TOOL_NAME,
+  CRON_DELETE_TOOL_NAME,
+  DEFAULT_MAX_AGE_DAYS,
+  isKairosCronEnabled,
+} from '../../tools/ScheduleCronTool/prompt.js'
+import { registerBundledSkill } from '../bundledSkills.js'
+
+const DEFAULT_INTERVAL = '10m'
+
+const USAGE_MESSAGE = `Usage: /loop [interval] <prompt>
+
+Run a prompt or slash command on a recurring interval.
+
+Intervals: Ns, Nm, Nh, Nd (e.g. 5m, 30m, 2h, 1d). Minimum granularity is 1 minute.
+If no interval is specified, defaults to ${DEFAULT_INTERVAL}.
+
+Examples:
+  /loop 5m /babysit-prs
+  /loop 30m check the deploy
+  /loop 1h /standup 1
+  /loop check the deploy          (defaults to ${DEFAULT_INTERVAL})
+  /loop check the deploy every 20m`
+
+function buildPrompt(args: string): string {
+  return `# /loop — schedule a recurring prompt
+
+Parse the input below into \`[interval] <prompt…>\` and schedule it with ${CRON_CREATE_TOOL_NAME}.
+
+## 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 \`${DEFAULT_INTERVAL}\` and the entire input is the prompt.
+
+If the resulting prompt is empty, show usage \`/loop [interval] <prompt>\` and stop — do not call ${CRON_CREATE_TOOL_NAME}.
+
+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 \`${DEFAULT_INTERVAL}\`, prompt \`check the deploy\` (rule 3)
+- \`check every PR\` → interval \`${DEFAULT_INTERVAL}\`, 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.
+
+## Action
+
+1. Call ${CRON_CREATE_TOOL_NAME} 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 ${DEFAULT_MAX_AGE_DAYS} days, and that they can cancel sooner with ${CRON_DELETE_TOOL_NAME} (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
+
+${args}`
+}
+
+export function registerLoopSkill(): void {
+  registerBundledSkill({
+    name: 'loop',
+    description:
+      'Run a prompt or slash command on a recurring interval (e.g. /loop 5m /foo, defaults to 10m)',
+    whenToUse:
+      'When the user wants to set up a recurring task, poll for status, or run something repeatedly on an interval (e.g. "check the deploy every 5 minutes", "keep running /babysit-prs"). Do NOT invoke for one-off tasks.',
+    argumentHint: '[interval] <prompt>',
+    userInvocable: true,
+    isEnabled: isKairosCronEnabled,
+    async getPromptForCommand(args) {
+      const trimmed = args.trim()
+      if (!trimmed) {
+        return [{ type: 'text', text: USAGE_MESSAGE }]
+      }
+      return [{ type: 'text', text: buildPrompt(trimmed) }]
+    },
+  })
+}