Task Trigger Skill

This skill enables you to register, manage, and execute scheduled tasks using the OS native scheduler. You'll convert natural language into cron expressions, create task definitions, integrate with crontab (Linux/WSL) or launchd (macOS), and handle logs.

Core Concept

user: "every day at 9am summarize my memory MCP entries"
  └→ You execute: /task-trigger:add
       └→ You write crontab entry (Linux) or .plist (macOS)
            └→ At scheduled time: CLI runs headless (opencode run or kiro chat)
                 └→ Output goes to log file
                      └→ User reads log when ready

Commands

Command	Description
`/task-trigger:add`	Register a new task interactively (ALWAYS ask confirmation)
`/task-trigger:watch`	Start monitoring a file/directory for changes
`/task-trigger:list`	Show all registered tasks
`/task-trigger:watchers`	List active file watchers
`/task-trigger:remove <id>`	Remove a task + clean scheduler
`/task-trigger:unwatch <id>`	Stop monitoring a file/directory
`/task-trigger:logs [id]`	View execution history
`/task-trigger:run <id>`	Execute task immediately
`/task-trigger:status`	Check scheduler health + time remaining

Available Scripts

This skill includes pre-built scripts for common operations. Use them to ensure consistency and reduce manual bash code:

Script	Purpose	Usage
`detect-platform.sh`	Detect OS platform	`./scripts/detect-platform.sh` → outputs: `wsl` , `macos` , or `linux`
`detect-cli.sh`	Detect available CLI	`./scripts/detect-cli.sh` → outputs: full path (e.g. `/usr/local/bin/opencode` ) or `none`
`add-to-crontab.sh`	Add task to crontab	`./scripts/add-to-crontab.sh --task-id <id> --cron <expr> --command <cmd> [--dry-run]`
`add-to-launchd.sh`	Add task to launchd	`./scripts/add-to-launchd.sh --task-id <id> --hour <H> --minute <M> --command <cmd> [--dry-run]`
`detect-watcher.sh`	Detect file monitoring tools	`./scripts/detect-watcher.sh` → outputs: `inotifywait` , `fswatch` , `polling` , or `none`
`start-watcher.sh`	Start file/directory watcher	`./scripts/start-watcher.sh --task-id <id> --path <path> --events <events> --command <cmd> [--dry-run]`
`stop-watcher.sh`	Stop file watcher	`./scripts/stop-watcher.sh <task-id>`
`list-tasks.py`	List registered tasks	`./scripts/list-tasks.py`
`list-watchers.py`	List active file watchers	`./scripts/list-watchers.py`
`remove-task.sh`	Remove task completely	`./scripts/remove-task.sh <task-id>`
`view-logs.sh`	View task logs	`./scripts/view-logs.sh [task-id] [--tail] [--lines N]`
`run-task.sh`	Execute task now	`./scripts/run-task.sh <task-id>`

IMPORTANT:

Always use scripts for repetitive operations instead of writing bash code manually.
Run
```
chmod +x scripts/*.sh
```
after first install to ensure all scripts are executable.

How to Use This Skill

1. Natural Language Parsing

You MUST parse natural language into cron expressions. This is best done by you (the agent) because you understand context and nuances.

Examples:

"every day at 9am" →
```
0 9 * * *
```
"every hour" →
```
0 * * * *
```
"every minute during the next 30 minutes" →
```
*/1 * * * *
```
+
```
duration_minutes: 30
```
"every Monday at 8:30am" →
```
30 8 * * 1
```
"cada día a las 10am" →
```
0 10 * * *
```
"cada minuto durante la próxima hora" →
```
*/1 * * * *
```
+
```
duration_minutes: 60
```

Duration handling: When user says "durante la próxima X", calculate expiration time.

2. CLI Detection

detect-cli.sh

returns the full path to the CLI binary (e.g.

/usr/local/bin/opencode

/Users/you/.local/bin/kiro-cli

). Store this full path in the task JSON — launchd and crontab don't inherit the user's PATH.

bash

CLI_PATH=$(./scripts/detect-cli.sh)
echo "Detected CLI: $CLI_PATH"
# Use $CLI_PATH in commands, not just "opencode" or "kiro-cli"

3. Platform Detection

Use the script instead of manual bash:

bash

# Instead of writing bash code, use:
PLATFORM=$(./scripts/detect-platform.sh)
echo "Detected platform: $PLATFORM"

Task Creation Workflow

Step 1: Parse User Request

User: "every day at 9am summarize my memory MCP entries using deepseek"
→ You extract:
   - Trigger: "every day at 9am" → cron: `0 9 * * *`
   - Prompt: "summarize my memory MCP entries"
   - Model: "deepseek" (if mentioned, else null)
   - CLI: detect with full path

Step 2: Generate Task ID

Create unique ID:

daily-memory-summary

log-analysis-30min

, etc. Rules: lowercase, hyphens, based on description.

Step 3: Create Task JSON

Create

$HOME/.task-trigger/tasks.json

(create directory if doesn't exist).

The file is a plain JSON array:

[{task1}, {task2}, ...]

For cron-based tasks:

json

{
  "id": "daily-memory-summary",
  "name": "Daily Memory Summary",
  "enabled": true,
  "trigger": {
    "type": "cron",
    "expression": "0 9 * * *",
    "timezone": "local",
    "duration_minutes": null,
    "expires_at": null
  },
  "execution": {
    "cli_path": "/usr/local/bin/opencode",
    "agent": "opencode",
    "model": "deepseek/deepseek-chat",
    "prompt": "Check MCP memory for new entries since yesterday and summarize them. Write output to $HOME/.task-trigger/logs/daily-memory-summary.log",
    "workingDirectory": "$HOME",
    "timeout": 300
  },
  "created_at": "2026-03-18T10:00:00Z",
  "log_path": "$HOME/.task-trigger/logs/daily-memory-summary.log"
}

For file watcher tasks:

json

{
  "id": "log-file-watcher",
  "name": "Log File Watcher",
  "enabled": true,
  "trigger": {
    "type": "file",
    "path": "/var/log/myapp.log",
    "watch_events": ["create", "modify"],
    "recursive": false,
    "poll_interval": 5,
    "debounce": 1
  },
  "execution": {
    "agent": "opencode",
    "model": "deepseek/deepseek-chat",
    "prompt": "New log entry detected. Analyze the latest lines and notify if errors found. Write output to $HOME/.task-trigger/logs/log-analyzer.log",
    "workingDirectory": "$HOME",
    "timeout": 60
  },
  "created_at": "2026-03-18T10:00:00Z",
  "log_path": "$HOME/.task-trigger/logs/log-analyzer.log"
}

Step 4: Platform-Specific Integration

For WSL/Linux (crontab):

bash

CLI_PATH=$(./scripts/detect-cli.sh)

# Build command using full path
if [[ "$CLI_PATH" == *opencode* ]]; then
  COMMAND="$CLI_PATH run --prompt 'your prompt here'"
else
  # kiro needs --trust-all-tools for file writes
  COMMAND="$CLI_PATH chat --no-interactive --trust-all-tools 'your prompt here'"
fi

# Preview first, then apply
./scripts/add-to-crontab.sh \
  --task-id "daily-memory-summary" \
  --cron "0 9 * * *" \
  --command "$COMMAND" \
  --dry-run

# If looks good, run without --dry-run

For macOS (launchd):

bash

CLI_PATH=$(./scripts/detect-cli.sh)

if [[ "$CLI_PATH" == *opencode* ]]; then
  COMMAND="$CLI_PATH run --prompt 'your prompt here'"
else
  COMMAND="$CLI_PATH chat --no-interactive --trust-all-tools 'your prompt here'"
fi

./scripts/add-to-launchd.sh \
  --task-id "daily-memory-summary" \
  --hour 9 \
  --minute 0 \
  --command "$COMMAND"

Step 5: Create Log Directory

bash

mkdir -p $HOME/.task-trigger/logs
mkdir -p $HOME/.task-trigger/launchd  # macOS only
mkdir -p $HOME/.task-trigger/watchers  # For file watchers

Step 6: Confirm to User

Show summary:

Task ID:
```
daily-memory-summary
```
Schedule:
```
0 9 * * *
```
(every day at 9am)
CLI:
```
/usr/local/bin/opencode
```
(full path)
Model:
```
deepseek/deepseek-chat
```
(or "last used model" if not specified)

Logs:

$HOME/.task-trigger/logs/daily-memory-summary.log

Platform: WSL/macOS/Linux
Status: Enabled

File Watcher Workflow

Step 1: Parse User Request

User: "watch my log file at /var/log/app.log and analyze new entries"
→ You extract:
   - Path: "/var/log/app.log"
   - Events: ["modify"] (default for files)
   - Prompt: "analyze new log entries"
   - CLI: detect opencode/kiro

Step 2: Generate Task ID

Create unique ID:

log-file-watcher

config-monitor

, etc.

Step 3: Create Task JSON (File Trigger)

Use the file trigger format shown in Step 3.

Step 4: Start Watcher

bash

CLI_PATH=$(./scripts/detect-cli.sh)

if [[ "$CLI_PATH" == *opencode* ]]; then
  COMMAND="$CLI_PATH run --prompt 'New log entry detected. Analyze the latest lines and notify if errors found.'"
else
  COMMAND="$CLI_PATH chat --no-interactive --trust-all-tools 'New log entry detected. Analyze the latest lines and notify if errors found.'"
fi

./scripts/start-watcher.sh \
  --task-id "log-file-watcher" \
  --path "/var/log/app.log" \
  --events "modify" \
  --command "$COMMAND" \
  --debounce 1

Step 5: Confirm to User

Show summary:

Task ID:
```
log-file-watcher
```
Path:
```
/var/log/app.log
```
Events:
```
modify
```
Tool:
```
inotifywait
```
(or detected tool)
CLI:
```
opencode
```
/
```
kiro
```
Status: Watching

Special Cases

Temporal Tasks ("during next X")

User: "check logs every minute during the next 30 minutes"
→ cron: `*/1 * * * *`
→ duration_minutes: 30
→ expires_at: current_time + 30 minutes

Implementation: When creating temporal tasks:

Calculate
```
expires_at
```
= current_time + duration_minutes
Store both
```
duration_minutes
```
and
```
expires_at
```
in task JSON
The
```
run-task.sh
```
script checks
```
expires_at
```
before executing — if expired, it disables the task and removes it from the scheduler automatically
```
/task-trigger:status
```
shows time remaining for temporal tasks

Model Specification

User: "using opencode/zen" or "con claude-3.5-sonnet"
→ Add to command: --model "opencode/zen"
→ If not specified: omit --model flag (uses last model)

Prompt Templates

Prompts support variable substitution for reusable tasks:

```
{{TIMESTAMP}}
```
→ current ISO 8601 timestamp
```
{{FILE_PATH}}
```
→ the watched file path (file watchers only)
```
{{TASK_ID}}
```
→ the task's ID
```
{{LOG_PATH}}
```
→ the task's log file path

Example:

"prompt": "Analyze {{FILE_PATH}} for errors since {{TIMESTAMP}}. Write results to {{LOG_PATH}}"

The agent expands these variables at execution time in

run-task.sh

Working Directory

Always use

$HOME

(not

) in scheduled commands.

File Watcher Events

Available events:

create

modify

delete

move

Files: Use
```
modify
```
for content changes
Directories: Use
```
create
```
,
```
delete
```
,
```
move
```
for structure changes
Default:
```
modify
```
for files,
```
create,modify,delete
```
for directories

Task Management

Listing Tasks (

/task-trigger:list

)

Use the script instead of manual JSON parsing:

bash

./scripts/list-tasks.py

Listing Watchers (

/task-trigger:watchers

)

List active file watchers:

bash

./scripts/list-watchers.py

Removing Tasks (

/task-trigger:remove <id>

)

Use the script instead of manual removal:

bash

./scripts/remove-task.sh <task-id>

Stopping Watchers (

/task-trigger:unwatch <id>

)

Stop a file watcher:

bash

./scripts/stop-watcher.sh <task-id>

Viewing Logs (

/task-trigger:logs [id]

)

Use the script instead of manual log viewing:

bash

# List all available logs
./scripts/view-logs.sh

# View specific log (last 50 lines)
./scripts/view-logs.sh <task-id>

# Tail log in real-time
./scripts/view-logs.sh <task-id> --tail

# View more lines
./scripts/view-logs.sh <task-id> --lines 100

Running Immediately (

/task-trigger:run <id>

)

Use the script instead of manual execution:

bash

./scripts/run-task.sh <task-id>

Checking Status (

/task-trigger:status

)

Verify scheduler is running (crontab entries / launchctl list)
Show temporal tasks with time remaining until
```
expires_at
```
Show last execution timestamp and result from log
Show next scheduled execution time
Check log directory health

CLI Commands Reference

opencode

Headless command:
```
opencode run --prompt "message"
```
Model flag:
```
-m "provider/model"
```

Example:

opencode run --prompt "Check memory" -m "deepseek/deepseek-chat"

kiro

Binary name:
```
kiro-cli
```
(not
```
kiro
```
)

Headless command:

kiro-cli chat --no-interactive "message"

Trust flag:
```
--trust-all-tools
```
(required for file writes and tool access)
Model flag:
```
--model "provider/model"
```

Example:

kiro-cli chat --no-interactive --trust-all-tools "Check memory" --model "anthropic/claude-sonnet-4"

Important: Always use

--trust-all-tools

with kiro headless commands, otherwise the agent cannot write files or use tools.

Important Rules

ALWAYS:

Ask confirmation before modifying crontab/launchd
Use scripts for detection instead of manual bash code
Parse natural language into cron expressions (agent's strength)
Handle temporal tasks with duration/expiration and auto-cleanup

Create necessary directories (

$HOME/.task-trigger/

logs/

launchd/

watchers/

)

Use structured logs with timestamps
Include model flag ONLY if user explicitly mentions model
Use $HOME, not ~ in scheduled commands and paths
Verify CLI commands with
```
--help
```
when uncertain
Prefer scripts over manual operations for consistency
Detect available watcher tool before starting file monitoring
Set appropriate debounce for file watchers (1-5 seconds)
Store full CLI path in task JSON (from
```
detect-cli.sh
```
)
Use --trust-all-tools with kiro headless commands
Use --dry-run to preview changes before applying
Ensure scripts are executable (
```
chmod +x
```
) before first use

NEVER:

Use
```
--dangerously-skip-permissions
```
Perform git operations
Depend on MCP sampling
Modify files without explicit instruction
Assume Windows Task Scheduler

Troubleshooting

Common Issues:

Crontab not available: User may need to install cron service
Launchd permissions: macOS may require full disk access
opencode/kiro not in PATH: Suggest adding to PATH or using full path
$HOME expansion: Some shells may not expand $HOME in crontab

Error Handling:

If platform detection fails, ask user
If CLI not found, suggest installation
If cron expression invalid, show examples
If write permission denied, suggest
```
sudo
```
(with warning)

Examples for Testing

Test these cases:

```
every day at 9am summarize memory
```
```
cada hora analiza logs usando deepseek
```

every minute during the next 30 minutes check emails

cada minuto durante la próxima hora revisa sistema

Monday and Wednesday at 8:30am backup files

watch my log file at /var/log/app.log and alert on errors

monitor the downloads folder for new PDF files

if config.json changes, restart the service

when new files appear in /data/uploads, process them

track changes to source code and run tests

Remember: You are the agent implementing this. Follow these instructions precisely, parse natural language, detect environment, and always confirm before making changes.

task-trigger

NPX Install

Tags

SKILL.md Content

Task Trigger Skill

Core Concept

Commands

Available Scripts

How to Use This Skill

1. Natural Language Parsing

2. CLI Detection

3. Platform Detection

Task Creation Workflow

Step 1: Parse User Request

Step 2: Generate Task ID

Step 3: Create Task JSON

For cron-based tasks:

For file watcher tasks:

Step 4: Platform-Specific Integration

For WSL/Linux (crontab):

For macOS (launchd):

Step 5: Create Log Directory

Step 6: Confirm to User

File Watcher Workflow

Step 1: Parse User Request

Step 2: Generate Task ID

Step 3: Create Task JSON (File Trigger)

Step 4: Start Watcher

Step 5: Confirm to User

Special Cases

Temporal Tasks ("during next X")

Model Specification

Prompt Templates

Working Directory

File Watcher Events

Task Management

Listing Tasks (/task-trigger:list)

Listing Watchers (/task-trigger:watchers)

Removing Tasks (/task-trigger:remove <id>)

Stopping Watchers (/task-trigger:unwatch <id>)

Viewing Logs (/task-trigger:logs [id])

Running Immediately (/task-trigger:run <id>)

Checking Status (/task-trigger:status)

CLI Commands Reference

opencode

kiro

Important Rules

ALWAYS:

NEVER:

Troubleshooting

Common Issues:

Error Handling:

Examples for Testing

Listing Tasks (
`/task-trigger:list`
)

Listing Watchers (
`/task-trigger:watchers`
)

Removing Tasks (
`/task-trigger:remove <id>`
)

Stopping Watchers (
`/task-trigger:unwatch <id>`
)

Viewing Logs (
`/task-trigger:logs [id]`
)

Running Immediately (
`/task-trigger:run <id>`
)

Checking Status (
`/task-trigger:status`
)