openclacky 0.9.19 → 0.9.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b959a76ace0015ec6279b1572afa3e961d862d9c856c9fdecc98f72d9e190e59
-  data.tar.gz: 53cc27fce3b47e83cb428955eb6591d53acc148cdab55721c7c32330b351fed0
+  metadata.gz: 803023a686f9005d8bbed56fa2604d6cb4a426ba2ff1c24ddf6e297242c7faed
+  data.tar.gz: ee8738600a36146e4f56b8605a917066746b31e370a41c3e245066ec4e4e961c
 SHA512:
-  metadata.gz: 5b0d27875497a290060cabfc409c5b8a18b90b95c8bec82157f8d1f8e63a25fc78e3d52bff8bcbf3bd9969f8e65090137dc7ce7b394ac35779412a51534a166e
-  data.tar.gz: 2b08d76c821e84c7196b4bc6364323879669259895b30cb803e01e70c49a59f44a40f5f607f8a4d3e10a96bfaa47167c03ed991fcebe6a5dcb44d099b18bdccd
+  metadata.gz: b5b27887365a698d193fee92d0672315c48963a9748509cae8a6b5426d0169f16b9fad709afa2232d80542999fc931ee48e09f2cee35100b39273b33c324b558
+  data.tar.gz: 5c5572d8a7b34af4eb03220dbf0e566ed0d2ab7b7278a89d8801f0c9ca58b100c90dd27fd17d1548016b21c20e1e458889a97a54983309c409479b863fc8b6ca

data/CHANGELOG.md

@@ -7,6 +7,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.9.20] - 2026-03-30
+
+### Added
+- **SSL error retry**: LLM API calls now automatically retry on SSL errors (same as other network failures — up to 10 retries with 5s delay)
+
+### Fixed
+- **Brand wrapper not found under root**: the install script now places the brand command wrapper in the same directory as the `openclacky` binary, so it is always on PATH regardless of whether running as root or a normal user
+
+### Improved
+- **Cron task management refactored to API**: cron task CRUD operations now go through the HTTP API instead of running ad-hoc Ruby scripts, making the scheduler more reliable and easier to maintain
+- **UTF-8 encoding fix for browser tool on Windows**: browser command output with non-ASCII characters no longer causes encoding errors
+
+### More
+- Installer no longer adds `~/.local/bin` to PATH (wrapper now colocated with gem binary, making the extra PATH entry unnecessary)
+- Brand install tips in Windows PowerShell installer
+
 ## [0.9.19] - 2026-03-29
 
 ### Added

data/docs/c-end-user-positioning.md

@@ -0,0 +1,64 @@
+# C-End User Positioning
+
+> Date: 2026-03-30
+
+---
+
+## Market Context
+
+The "OpenClaw ecosystem" has exploded in 2026. Key players:
+
+- **OpenClaw** — open-source, self-hosted, community Skills. Designed for technical users who configure everything themselves.
+- **QClaw** — Tencent's fork. Bundled Kimi model, WeChat binding. Mass-market but Tencent-ecosystem only.
+- **Others** (Wukong, etc.) — same lane.
+
+OpenClaw has 5,700+ Skills, but almost all are open-source, free, and easily copied. The ecosystem lacks **expertise-backed, production-grade Skills worth paying for**.
+
+---
+
+## Who openclacky Is For
+
+**Ordinary users, not technical geeks.**
+
+The target user knows OpenClaw exists, has heard about "raising a lobster", but can't or doesn't want to:
+- configure Docker / environment / webhooks
+- manage their own API keys without knowing what they'll spend
+- troubleshoot when a long task breaks halfway
+
+They want to use a lobster built by an expert (a lawyer, a trader, an SEO specialist) — not build one themselves.
+
+> Core insight: **OpenClaw is built for people who create Skills. openclacky is built for people who use them.**
+
+---
+
+## Why openclacky Over OpenClaw: 3 Core Reasons
+
+### 1. Zero-friction IM setup — the strongest differentiator
+
+OpenClaw requires users to manually configure webhooks, tokens, and config files to connect WeChat / Feishu / WeCom. High technical barrier, most ordinary users give up.
+
+openclacky uses **AI-automated channel setup**: one sentence, and the AI configures the IM connection for you — no plugins, no docs, no engineering knowledge required. This is a genuine technical moat.
+
+### 2. Built for China, natively
+
+- No VPN required, no overseas credit card
+- WeChat / Feishu / WeCom are the primary daily tools for Chinese users — openclacky treats them as first-class citizens
+- Supports domestic models (DeepSeek, Kimi, etc.) out of the box
+- QClaw is domestic too, but locked to Tencent's ecosystem and model choices
+
+### 3. Cost transparency and long-task reliability
+
+- Real-time token cost tracking — users always know what they're spending
+- Automatic compression (up to 90% savings via Insert-then-Compress + Prompt Caching)
+- Long tasks don't break: sub-agent isolation + Time Machine architecture keeps context intact
+
+---
+
+## The User Progression
+
+```
+Can use it  →  Dare to use it  →  Keep using it
+(zero setup)   (cost clarity)     (tasks don't break)
+```
+
+Each of the 3 reasons maps directly to one stage of this progression.

data/lib/clacky/agent/llm_caller.rb

@@ -34,7 +34,7 @@ module Clacky
             max_tokens: @config.max_tokens,
             enable_caching: @config.enable_prompt_caching
           )
-        rescue Faraday::ConnectionFailed, Faraday::TimeoutError, Errno::ECONNREFUSED, Errno::ETIMEDOUT => e
+        rescue Faraday::ConnectionFailed, Faraday::TimeoutError, Faraday::SSLError, Errno::ECONNREFUSED, Errno::ETIMEDOUT => e
           @ui&.clear_progress
           retries += 1
           if retries <= max_retries

data/lib/clacky/default_skills/cron-task-creator/SKILL.md

@@ -17,21 +17,14 @@ Storage:
   ~/.clacky/schedules.yml        # All scheduled plans (YAML list)
   ~/.clacky/logger/clacky-*.log  # Execution logs (daily rotation)
 
-WebUI Task Panel (Clacky Web Interface):
-  - Automatically reads tasks/ + schedules.yml and renders the task list
-  - Each row shows task name, cron expression, and content preview
-  - Action buttons: ▶ Run (execute now), ✎ Edit (edit in session), ✕ (delete)
-  - Run button triggers POST /api/tasks/run → executes task in a new session
-
-API Endpoints (available when clacky server is running):
-  GET    /api/tasks              → list all tasks
-  POST   /api/tasks              → create task {name, content}
-  GET    /api/tasks/:name        → get task content
-  DELETE /api/tasks/:name        → delete task
-  POST   /api/tasks/run          → run immediately {name}
-  GET    /api/schedules          → list all schedules
-  POST   /api/schedules          → create schedule {name, task, cron}
-  DELETE /api/schedules/:name    → delete schedule
+API Base: http://${CLACKY_SERVER_HOST}:${CLACKY_SERVER_PORT}
+
+Cron-Tasks API (unified — manages task file + schedule together):
+  GET    /api/cron-tasks              → list all cron tasks with schedule info
+  POST   /api/cron-tasks              → create task + schedule {name, content, cron, enabled?}
+  PATCH  /api/cron-tasks/:name        → update {content?, cron?, enabled?}
+  DELETE /api/cron-tasks/:name        → delete task file + schedule
+  POST   /api/cron-tasks/:name/run    → execute immediately (creates a new session)
 ```
 
 ## Cron Expression Quick Reference
@@ -54,10 +47,11 @@ Field order: `minute hour day-of-month month day-of-week`
 
 ### 1. LIST — Show all tasks
 
-When user asks "what tasks do I have", "list scheduled tasks", etc.:
+```bash
+curl -s http://${CLACKY_SERVER_HOST}:${CLACKY_SERVER_PORT}/api/cron-tasks
+```
 
-1. Run `ruby ~/.clacky/skills/cron-task-creator/scripts/list_tasks.rb`
-2. Display results: task name, cron schedule, enabled status, last run status
+Display each task: name, cron schedule, enabled status, content preview.
 
 If no tasks exist, inform the user and offer to create one or show templates.
 
@@ -69,15 +63,14 @@ If no tasks exist, inform the user and offer to create one or show templates.
 
 **Step 1: Gather required info** (only ask for what's missing)
 - What should the task DO? (goal, behavior, output format)
-- How often should it run? (or is it manual-only?)
+- How often should it run? (or is it manual-only without a schedule?)
 - Any specific parameters? (URLs, file paths, output location, language)
 
 **Step 2: Generate task name**
 - Rule: only `[a-z0-9_-]`, lowercase, no spaces
 - Examples: `daily_report`, `price_monitor`, `weekly_summary`
 
-**Step 3: Write the task prompt file**
-Path: `~/.clacky/tasks/<name>.md`
+**Step 3: Write the task prompt**
 
 The prompt must be:
 - **Self-contained**: the agent running it has zero prior context — include everything needed
@@ -85,7 +78,7 @@ The prompt must be:
 - **Detailed**: include URLs, file paths, output format, language, expected output location
 
 Good task prompt example:
-```markdown
+```
 You are a price monitoring assistant. Complete the following task:
 
 ## Goal
@@ -100,14 +93,17 @@ Check the current BTC price on CoinGecko, compare with yesterday's price, and lo
 Execute immediately.
 ```
 
-**Step 4: Write file and add schedule**
+**Step 4: Create via API**
 
 ```bash
-# Write task file
-ruby ~/.clacky/skills/cron-task-creator/scripts/manage_task.rb create "<name>" "<content>"
-
-# Add schedule (if applicable)
-ruby ~/.clacky/skills/cron-task-creator/scripts/manage_schedule.rb add "<name>" "<task_name>" "<cron_expr>"
+curl -s -X POST http://${CLACKY_SERVER_HOST}:${CLACKY_SERVER_PORT}/api/cron-tasks \
+  -H "Content-Type: application/json" \
+  -d '{
+    "name": "task_name",
+    "content": "task prompt content...",
+    "cron": "0 9 * * *",
+    "enabled": true
+  }'
 ```
 
 **Step 5: Confirm creation**
@@ -116,7 +112,6 @@ ruby ~/.clacky/skills/cron-task-creator/scripts/manage_schedule.rb add "<name>"
 ✅ Task created successfully!
 
 📋 Task name: daily_standup
-📄 File: ~/.clacky/tasks/daily_standup.md
 ⏰ Schedule: Weekdays at 09:00 (cron: 0 9 * * 1-5)
 
 View and manage this task in the Clacky WebUI → Tasks panel. Click ▶ Run to execute immediately.
@@ -126,24 +121,27 @@ View and manage this task in the Clacky WebUI → Tasks panel. Click ▶ Run to
 
 ### 3. EDIT — Modify an existing task
 
-When the user wants to change task content, cron schedule, or rename:
+**Step 1**: Identify the task (if unclear, LIST first and ask)
 
-**Step 1**: Identify the task to modify (if unclear, LIST first and ask)
+**Step 2**: Show current state via LIST or ask user to confirm
 
-**Step 2**: Show current state (first 10 lines + cron expression)
-
-**Step 3**: Determine what to change
-- Prompt only → rewrite `~/.clacky/tasks/<name>.md`
-- Schedule only → update `cron` field in `schedules.yml`
-- Both → do both
-- Rename → rename .md file + update schedules.yml
+**Step 3**: Update via API
 
 ```bash
-# Update task content
-ruby ~/.clacky/skills/cron-task-creator/scripts/manage_task.rb update "<name>" "<new_content>"
-
-# Update cron schedule
-ruby ~/.clacky/skills/cron-task-creator/scripts/manage_schedule.rb update "<schedule_name>" "<new_cron>"
+# Update content only
+curl -s -X PATCH http://${CLACKY_SERVER_HOST}:${CLACKY_SERVER_PORT}/api/cron-tasks/task_name \
+  -H "Content-Type: application/json" \
+  -d '{"content": "new prompt content..."}'
+
+# Update cron schedule only
+curl -s -X PATCH http://${CLACKY_SERVER_HOST}:${CLACKY_SERVER_PORT}/api/cron-tasks/task_name \
+  -H "Content-Type: application/json" \
+  -d '{"cron": "0 8 * * 1-5"}'
+
+# Update both
+curl -s -X PATCH http://${CLACKY_SERVER_HOST}:${CLACKY_SERVER_PORT}/api/cron-tasks/task_name \
+  -H "Content-Type: application/json" \
+  -d '{"content": "...", "cron": "0 8 * * 1-5"}'
 ```
 
 **Step 4**: Confirm changes
@@ -151,7 +149,6 @@ ruby ~/.clacky/skills/cron-task-creator/scripts/manage_schedule.rb update "<sche
 ```
 ✅ Task updated!
 📋 daily_standup
-  Prompt: updated ✓
   Schedule: 0 9 * * 1-5 → 0 8 * * 1-5 (now weekdays at 08:00)
 ```
 
@@ -160,7 +157,15 @@ ruby ~/.clacky/skills/cron-task-creator/scripts/manage_schedule.rb update "<sche
 ### 4. ENABLE / DISABLE — Toggle a task
 
 ```bash
-ruby ~/.clacky/skills/cron-task-creator/scripts/manage_schedule.rb toggle "<schedule_name>" true|false
+# Disable
+curl -s -X PATCH http://${CLACKY_SERVER_HOST}:${CLACKY_SERVER_PORT}/api/cron-tasks/task_name \
+  -H "Content-Type: application/json" \
+  -d '{"enabled": false}'
+
+# Enable
+curl -s -X PATCH http://${CLACKY_SERVER_HOST}:${CLACKY_SERVER_PORT}/api/cron-tasks/task_name \
+  -H "Content-Type: application/json" \
+  -d '{"enabled": true}'
 ```
 
 Confirm:
@@ -180,15 +185,22 @@ Always confirm before deleting (unless the user has explicitly said to delete):
 ```
 
 ```bash
-ruby ~/.clacky/skills/cron-task-creator/scripts/manage_task.rb delete "<name>"
+curl -s -X DELETE http://${CLACKY_SERVER_HOST}:${CLACKY_SERVER_PORT}/api/cron-tasks/task_name
 ```
 
 ---
 
 ### 6. HISTORY — View run history
 
+Read the daily log files directly:
+
 ```bash
-ruby ~/.clacky/skills/cron-task-creator/scripts/task_history.rb "<task_name>"
+grep "task_name" ~/.clacky/logger/clacky-$(date +%Y-%m-%d).log | tail -20
+```
+
+Or search across recent days:
+```bash
+grep -h "task_name" ~/.clacky/logger/clacky-*.log | tail -30
 ```
 
 Display format:
@@ -198,24 +210,21 @@ Display format:
 Mar 10  19:00  ❌ Failed  — JSON::ParserError: unexpected end of input
 Mar 09  19:00  ✅ Success — took 1m 42s
 Mar 08  19:00  ✅ Success — took 2m 10s
-Mar 07  19:00  ⚠️ Skipped — (task was disabled)
-
-Recent error:
-  JSON::ParserError at line 226
-  Possible cause: API response was truncated or empty
 ```
 
 ---
 
 ### 7. RUN NOW — Execute immediately
 
+```bash
+curl -s -X POST http://${CLACKY_SERVER_HOST}:${CLACKY_SERVER_PORT}/api/cron-tasks/task_name/run
 ```
-▶️ Go to the Clacky WebUI → Tasks panel, find the task, and click ▶ Run.
 
-The task will execute in a new session. You can watch it run in real time via the WebUI.
+This creates a new session. Tell the user:
+```
+▶️ Task started in a new session.
+   View it in the Clacky WebUI → Sessions panel.
 ```
-
-If the user wants to run the task in the current session, read the task file and execute the instructions directly.
 
 ---
 
@@ -243,8 +252,6 @@ Tell me which one interests you, or describe your own use case!
 ## Important Notes
 
 - Task names: only `[a-z0-9_-]`, no spaces, no uppercase
-- When modifying `schedules.yml`: always read → modify → write back the full file (never append directly)
 - Task prompt files must be **self-contained** — the executing agent has no prior memory
 - Clacky server must be running for cron to trigger automatically (checked every minute)
 - The WebUI Task Panel is the preferred interface for managing tasks — always remind the user to check it after changes
-- Path expansion: always use absolute paths, expand `~` to the actual home directory

data/lib/clacky/server/http_server.rb

@@ -315,11 +315,8 @@ module Clacky
         case [method, path]
         when ["GET",    "/api/sessions"]      then api_list_sessions(req, res)
         when ["POST",   "/api/sessions"]      then api_create_session(req, res)
-        when ["GET",    "/api/schedules"]     then api_list_schedules(res)
-        when ["POST",   "/api/schedules"]     then api_create_schedule(req, res)
-        when ["GET",    "/api/tasks"]         then api_list_tasks(res)
-        when ["POST",   "/api/tasks"]         then api_create_task(req, res)
-        when ["POST",   "/api/tasks/run"]     then api_run_task(req, res)
+        when ["GET",    "/api/cron-tasks"]    then api_list_cron_tasks(res)
+        when ["POST",   "/api/cron-tasks"]    then api_create_cron_task(req, res)
         when ["GET",    "/api/skills"]         then api_list_skills(res)
         when ["GET",    "/api/config"]        then api_get_config(res)
         when ["POST",   "/api/config"]        then api_save_config(req, res)
@@ -365,15 +362,15 @@ module Clacky
           elsif method == "DELETE" && path.start_with?("/api/sessions/")
             session_id = path.sub("/api/sessions/", "")
             api_delete_session(session_id, res)
-          elsif method == "DELETE" && path.start_with?("/api/schedules/")
-            name = URI.decode_www_form_component(path.sub("/api/schedules/", ""))
-            api_delete_schedule(name, res)
-          elsif method == "GET" && path.start_with?("/api/tasks/")
-            name = URI.decode_www_form_component(path.sub("/api/tasks/", ""))
-            api_get_task(name, res)
-          elsif method == "DELETE" && path.start_with?("/api/tasks/")
-            name = URI.decode_www_form_component(path.sub("/api/tasks/", ""))
-            api_delete_task(name, res)
+          elsif method == "POST" && path.match?(%r{^/api/cron-tasks/[^/]+/run$})
+            name = URI.decode_www_form_component(path.sub("/api/cron-tasks/", "").sub("/run", ""))
+            api_run_cron_task(name, res)
+          elsif method == "PATCH" && path.match?(%r{^/api/cron-tasks/[^/]+$})
+            name = URI.decode_www_form_component(path.sub("/api/cron-tasks/", ""))
+            api_update_cron_task(name, req, res)
+          elsif method == "DELETE" && path.match?(%r{^/api/cron-tasks/[^/]+$})
+            name = URI.decode_www_form_component(path.sub("/api/cron-tasks/", ""))
+            api_delete_cron_task(name, res)
           elsif method == "PATCH" && path.match?(%r{^/api/skills/[^/]+/toggle$})
             name = URI.decode_www_form_component(path.sub("/api/skills/", "").sub("/toggle", ""))
             api_toggle_skill(name, req, res)
@@ -1242,109 +1239,81 @@ module Clacky
         }
       end
 
-      # ── Schedules API ─────────────────────────────────────────────────────────
 
-      def api_list_schedules(res)
-        json_response(res, 200, { schedules: @scheduler.schedules })
+      # ── Cron-Tasks API ───────────────────────────────────────────────────────
+      # Unified API that manages task file + schedule as a single resource.
+
+      # GET /api/cron-tasks
+      def api_list_cron_tasks(res)
+        json_response(res, 200, { cron_tasks: @scheduler.list_cron_tasks })
       end
 
-      def api_create_schedule(req, res)
-        body = parse_json_body(req)
-        name = body["name"].to_s.strip
-        task = body["task"].to_s.strip
-        cron = body["cron"].to_s.strip
+      # POST /api/cron-tasks — create task file + schedule in one step
+      # Body: { name, content, cron, enabled? }
+      def api_create_cron_task(req, res)
+        body    = parse_json_body(req)
+        name    = body["name"].to_s.strip
+        content = body["content"].to_s
+        cron    = body["cron"].to_s.strip
+        enabled = body.key?("enabled") ? body["enabled"] : true
 
-        if name.empty? || task.empty? || cron.empty?
-          json_response(res, 422, { error: "name, task, and cron are required" })
-          return
-        end
+        return json_response(res, 422, { error: "name is required" })    if name.empty?
+        return json_response(res, 422, { error: "content is required" }) if content.empty?
+        return json_response(res, 422, { error: "cron is required" })    if cron.empty?
 
-        unless @scheduler.list_tasks.include?(task)
-          json_response(res, 422, { error: "Task not found: #{task}" })
-          return
+        fields = cron.strip.split(/\s+/)
+        unless fields.size == 5
+          return json_response(res, 422, { error: "cron must have 5 fields (min hour dom month dow)" })
         end
 
-        @scheduler.add_schedule(name: name, task: task, cron: cron)
+        @scheduler.create_cron_task(name: name, content: content, cron: cron, enabled: enabled)
         json_response(res, 201, { ok: true, name: name })
       end
 
-      def api_delete_schedule(name, res)
-        if @scheduler.remove_schedule(name)
-          json_response(res, 200, { ok: true })
-        else
-          json_response(res, 404, { error: "Schedule not found: #{name}" })
-        end
-      end
-
-      # ── Tasks API ─────────────────────────────────────────────────────────────
+      # PATCH /api/cron-tasks/:name — update content and/or cron/enabled
+      # Body: { content?, cron?, enabled? }
+      def api_update_cron_task(name, req, res)
+        body    = parse_json_body(req)
+        content = body["content"]
+        cron    = body["cron"]&.to_s&.strip
+        enabled = body["enabled"]
 
-      def api_list_tasks(res)
-        tasks = @scheduler.list_tasks.map do |name|
-          content = begin
-            @scheduler.read_task(name)
-          rescue StandardError
-            ""
-          end
-          { name: name, path: @scheduler.task_file_path(name), content: content }
+        if cron && cron.split(/\s+/).size != 5
+          return json_response(res, 422, { error: "cron must have 5 fields (min hour dom month dow)" })
         end
-        json_response(res, 200, { tasks: tasks })
-      end
 
-      def api_get_task(name, res)
-        content = @scheduler.read_task(name)
-        json_response(res, 200, { name: name, content: content })
+        @scheduler.update_cron_task(name, content: content, cron: cron, enabled: enabled)
+        json_response(res, 200, { ok: true, name: name })
       rescue => e
         json_response(res, 404, { error: e.message })
       end
 
-      def api_delete_task(name, res)
-        if @scheduler.delete_task(name)
+      # DELETE /api/cron-tasks/:name — remove task file + schedule
+      def api_delete_cron_task(name, res)
+        if @scheduler.delete_cron_task(name)
           json_response(res, 200, { ok: true })
         else
-          json_response(res, 404, { error: "Task not found: #{name}" })
+          json_response(res, 404, { error: "Cron task not found: #{name}" })
         end
       end
 
-      def api_create_task(req, res)
-        body    = parse_json_body(req)
-        name    = body["name"].to_s.strip
-        content = body["content"].to_s
-
-        if name.empty?
-          json_response(res, 422, { error: "name is required" })
-          return
-        end
-
-        @scheduler.write_task(name, content)
-        json_response(res, 201, { ok: true, name: name })
-      end
-
-      def api_run_task(req, res)
-        body = parse_json_body(req)
-        name = body["name"].to_s.strip
-
-        if name.empty?
-          json_response(res, 422, { error: "name is required" })
-          return
+      # POST /api/cron-tasks/:name/run — execute immediately
+      def api_run_cron_task(name, res)
+        unless @scheduler.list_tasks.include?(name)
+          return json_response(res, 404, { error: "Cron task not found: #{name}" })
         end
 
-        begin
-          prompt       = @scheduler.read_task(name)
-          session_name = "▶ #{name} #{Time.now.strftime("%H:%M")}"
-          working_dir  = File.expand_path("~/clacky_workspace")
-          FileUtils.mkdir_p(working_dir)
-
-          # Tasks run unattended — use auto_approve so request_user_feedback doesn't block.
-          session_id = build_session(name: session_name, working_dir: working_dir, permission_mode: :auto_approve)
+        prompt       = @scheduler.read_task(name)
+        session_name = "▶ #{name} #{Time.now.strftime("%H:%M")}"
+        working_dir  = File.expand_path("~/clacky_workspace")
+        FileUtils.mkdir_p(working_dir)
 
-          # Store the pending task prompt so the WS "run_task" message can start it
-          # after the client has subscribed and is ready to receive broadcasts.
-          @registry.update(session_id, pending_task: prompt, pending_working_dir: working_dir)
+        session_id = build_session(name: session_name, working_dir: working_dir, permission_mode: :auto_approve)
+        @registry.update(session_id, pending_task: prompt, pending_working_dir: working_dir)
 
-          json_response(res, 202, { ok: true, session: @registry.session_summary(session_id) })
-        rescue => e
-          json_response(res, 422, { error: e.message })
-        end
+        json_response(res, 202, { ok: true, session: @registry.session_summary(session_id) })
+      rescue => e
+        json_response(res, 422, { error: e.message })
       end
 
       # ── Skills API ────────────────────────────────────────────────────────────

data/lib/clacky/server/scheduler.rb

@@ -85,6 +85,61 @@ module Clacky
         list.size < before_count
       end
 
+      # Update an existing schedule entry (cron and/or enabled).
+      # Returns false if the schedule does not exist.
+      def update_schedule(name, cron: nil, enabled: nil)
+        list = load_schedules
+        entry = list.find { |s| s["name"] == name }
+        return false unless entry
+
+        entry["cron"]    = cron    unless cron.nil?
+        entry["enabled"] = enabled unless enabled.nil?
+        save_schedules(list)
+        true
+      end
+
+      # ── Composite cron-task helpers ──────────────────────────────────────────
+
+      # Create a task file and its schedule in one step.
+      def create_cron_task(name:, content:, cron:, enabled: true)
+        write_task(name, content)
+        add_schedule(name: name, task: name, cron: cron, enabled: enabled)
+      end
+
+      # Update a cron-task: optionally update content and/or schedule fields.
+      def update_cron_task(name, content: nil, cron: nil, enabled: nil)
+        raise "Cron task not found: #{name}" unless list_tasks.include?(name)
+
+        write_task(name, content) unless content.nil?
+        update_schedule(name, cron: cron, enabled: enabled) if cron || !enabled.nil?
+      end
+
+      # Delete a cron-task: remove both the task file and its schedule.
+      def delete_cron_task(name)
+        removed_schedule = remove_schedule(name)
+        removed_task     = delete_task(name)
+        removed_schedule || removed_task
+      end
+
+      # Return a merged list of cron-tasks (task content + schedule metadata).
+      def list_cron_tasks
+        schedule_map = load_schedules.each_with_object({}) do |s, h|
+          h[s["task"]] = s if s.is_a?(Hash)
+        end
+
+        list_tasks.map do |task_name|
+          content  = begin; read_task(task_name); rescue StandardError; ""; end
+          schedule = schedule_map[task_name] || {}
+          {
+            "name"    => task_name,
+            "content" => content,
+            "cron"    => schedule["cron"],
+            "enabled" => schedule.fetch("enabled", true),
+            "scheduled" => !schedule.empty?
+          }
+        end
+      end
+
       # ── Task file helpers ────────────────────────────────────────────────────
 
       # Read the prompt content of a named task.

data/lib/clacky/tools/browser.rb

@@ -486,7 +486,7 @@ module Clacky
       # -----------------------------------------------------------------------
 
       private def find_node_binary
-        path = `which node 2>/dev/null`.strip
+        path = Clacky::Utils::Encoding.cmd_to_utf8(`which node 2>/dev/null`, source_encoding: "UTF-8").strip
         return nil if path.empty? || !File.executable?(path)
         path
       end
@@ -494,7 +494,7 @@ module Clacky
       private def node_major_version
         node = find_node_binary
         return nil unless node
-        `#{node} --version 2>/dev/null`.strip.gsub(/^v/, "").split(".").first.to_i
+        Clacky::Utils::Encoding.cmd_to_utf8(`#{node} --version 2>/dev/null`, source_encoding: "UTF-8").strip.gsub(/^v/, "").split(".").first.to_i
       end
 
       private def node_error

data/lib/clacky/utils/encoding.rb

@@ -54,6 +54,27 @@ module Clacky
         str.encode("UTF-8", "UTF-8", invalid: :replace, undef: :replace, replace: "")
       end
 
+      # Convert raw shell command output to valid UTF-8.
+      # Handles two common cases:
+      #   - Windows commands (e.g. powershell.exe) that output GBK/CP936 bytes
+      #   - Unix commands that output UTF-8 or ASCII bytes with ASCII-8BIT encoding
+      #
+      # Strategy: try GBK decode first (superset of ASCII, covers Chinese Windows);
+      # if that fails fall back to UTF-8 scrub.
+      #
+      # @param data [String, nil] raw bytes from backtick / IO.popen
+      # @param source_encoding [String] hint for source encoding (default: "GBK")
+      # @return [String] valid UTF-8 string
+      def self.cmd_to_utf8(data, source_encoding: "GBK")
+        return "" if data.nil? || data.empty?
+
+        data.dup
+            .force_encoding(source_encoding)
+            .encode("UTF-8", invalid: :replace, undef: :replace, replace: "")
+      rescue Encoding::InvalidByteSequenceError, Encoding::UndefinedConversionError
+        to_utf8(data)
+      end
+
       # Return an ASCII-safe UTF-8 copy of *str* suitable for security regex
       # pattern matching.  Any byte that is not valid in the source encoding, or
       # that cannot be represented in UTF-8, is replaced with '?'.  The