@carllee1983/dbcli 1.8.0 → 1.9.0

package/CHANGELOG.md

@@ -5,6 +5,22 @@ All notable changes to dbcli are documented here.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.9.0] - 2026-05-06
+
+### Added
+
+- **Agent Task Packs（plan-only 第一版）**：`dbcli skill tasks list/show/plan` 讓 AI agent 可探索團隊定義的資料庫任務範本並產生安全可審查的執行計畫。
+  - 三層儲存：`assets/tasks/`（內建）< `.dbcli-shared/tasks/`（團隊共享）< `.dbcli/tasks/`（個人覆蓋）。
+  - Task 檔為 `.md`：YAML frontmatter（name/description/tags/engines/params/safety/steps）＋ markdown agent notes。
+  - 嚴格 schema：`safety.mode` 僅接受 `plan-only`、`step.type` 僅接受 `command`，未知欄位直接 fail 解析而非靜默忽略。
+  - `plan` 輸出包含原始 `command`、`resolvedCommand`、`argv`（shell-aware 切分），方便 agent 直接消費。
+  - 內建第一版 `diagnose-slow-query` 任務作為範例。
+- 文件：`assets/SKILL.md` 與 `assets/reference.md` 同步加入 Agent Task Packs 章節；`docs/feature-matrix.md` 補充 `skill tasks` 子命令說明。
+
+### Changed
+
+- `src/core/saved-queries/yaml-mini.ts`：擴充支援 YAML block list 語法（`- scalar`、`- key: value` 起始的 sub-map），以承載 Agent Task Packs 的 frontmatter；既有 saved-queries 解析行為不變、66 個既有測試全綠。
+
 ## [1.8.0] - 2026-05-06
 
 ### Added

package/README.md

@@ -114,7 +114,45 @@ dbcli query '{"status":"active"}' --collection users --use atlas
 
 For MongoDB, `list` and `query` operate on the database configured for the connection, and `query` requires `--collection <name>`.
 
-For a command-by-command support matrix across PostgreSQL, MySQL, MariaDB, and MongoDB, see [docs/feature-matrix.md](./docs/feature-matrix.md).
+For a command-by-command support matrix across PostgreSQL, MySQL, MariaDB, MongoDB, Redis, and Elasticsearch, see [docs/feature-matrix.md](./docs/feature-matrix.md).
+
+### Redis & Elasticsearch Support
+
+dbcli extends its unified interface to Redis and Elasticsearch, providing consistent discovery and querying.
+
+#### Redis
+
+```bash
+# Connect to Redis
+dbcli init --system redis --host localhost --port 6379
+
+# List keys (uses SCAN)
+dbcli list
+
+# Inspect a key (type, TTL, size, sample)
+dbcli schema my-key
+
+# Run Redis commands (whitelisted)
+dbcli query "GET my-key"
+dbcli query "HGETALL user:1"
+```
+
+#### Elasticsearch
+
+```bash
+# Connect to Elasticsearch
+dbcli init --system elasticsearch --host localhost --port 9200
+
+# List indices and document counts
+dbcli list
+
+# Show mapping/structure of an index
+dbcli schema my-index
+
+# Query using Lucene or DSL JSON
+dbcli query "status:active" --index my-index
+dbcli query '{"query": {"match_all": {}}}' --index my-index
+```
 
 ---
 

package/README.zh-TW.md

@@ -189,7 +189,7 @@ dbcli init [OPTIONS]
 ```
 
 **選項 (基本)：**
-- `--system <type>` — 資料庫系統：`postgresql`、`mysql`、`mariadb`、`mongodb`
+- `--system <type>` — 資料庫系統：`postgresql`、`mysql`、`mariadb`、`mongodb`、`redis`、`elasticsearch`
 - `--host <host>` — 主機
 - `--port <port>` — 埠號
 - `--user <user>` — 使用者

package/assets/SKILL.md

@@ -11,13 +11,32 @@ Database CLI for AI agents with permission-based access control.
 
 1. `dbcli status` — permission level and system summary (no credentials).
 2. `dbcli blacklist list` — sensitive data boundaries.
-3. `dbcli schema <table> --format json` — real column names. **Never guess.**
+3. `dbcli schema <table> --format json` — real column names (SQL/Mongo/ES) or `schema <key>` (Redis). **Never guess.**
 4. Run `query` / `insert` / `update` / `delete` / `export` within permission.
-5. All writes: `--dry-run` → run → `query` read-back to confirm.
+5. All writes: `--dry-run` (SQL/Mongo) → run → `query` read-back to confirm.
 
 Prefer `--format json` for agent-friendly output.
 
-Full flags, per-command copy-paste blocks, `migrate` DDL, interactive `shell`, and MongoDB walkthroughs are in [reference.md](reference.md) (installed next to this file).
+## Agent Task Packs
+
+When the user asks for a database workflow (e.g. "diagnose this slow query", "audit
+permissions", "review long-running operations"), prefer published task templates
+over inventing steps from memory.
+
+```bash
+dbcli skill tasks list --format json                              # discover
+dbcli skill tasks show <task>                                     # inspect
+dbcli skill tasks plan <task> --param key=value --format json     # generate plan
+```
+
+The plan output is an ordered list of dbcli commands with rationale and risk
+labels. Execute them one at a time — task plans do **not** override blacklist,
+schema, dry-run, or confirmation requirements.
+
+Tasks live under `assets/tasks/` (builtin), `.dbcli-shared/tasks/` (shared), and
+`.dbcli/tasks/` (local override).
+
+Full flags, per-command copy-paste blocks, `migrate` DDL, interactive `shell`, and MongoDB/Redis/ES walkthroughs are in [reference.md](reference.md) (installed next to this file).
 
 ## Quick start
 
@@ -34,8 +53,8 @@ dbcli query "SELECT * FROM users"   # Execute SQL (auto LIMIT 1000)
 | `init` | n/a | Create `.dbcli` (v1 single or v2 multi via `--conn-name` / `--env-file`). **Usually run by the human** — do NOT re-run to strip `{"$env"}` references; that format is intentional. |
 | `use` | n/a | Show/switch default named connection (v2 only). |
 | `list` | query-only+ | Tables (SQL), collections (MongoDB), keys (Redis), or indices (Elasticsearch). |
-| `schema` | query-only+ | SQL: per-table or full scan into `.dbcli/schemas/` (use `--use` for the right cache). MongoDB: sampled. ES: flattened mapping. Redis: per-key only (type/TTL/size). |
-| `query` | query-only+ | SQL, Mongo JSON (`--collection`), Redis command, or ES DSL/Lucene (`--collection`/`--index`). |
+| `schema` | query-only+ | SQL: per-table or full scan into `.dbcli/schemas/`. MongoDB: sampled. ES: flattened mapping. Redis: per-key only (type/TTL/size). |
+| `query` | query-only+ | SQL, Mongo JSON (`--collection`), Redis command, or ES DSL/Lucene (`--collection`). |
 | `insert` / `update` | read-write+ | SQL or MongoDB only. JSON `--data` / `--set`; `--where` required on `update`; `--dry-run` first. Redis writes go through `query`. |
 | `delete` | data-admin+ | SQL or MongoDB only. `--where` required; `--dry-run` first. |
 | `export` | query-only+ | SQL or MongoDB only. Query → CSV/JSON(L) file or stdout. |
@@ -43,11 +62,11 @@ dbcli query "SELECT * FROM users"   # Execute SQL (auto LIMIT 1000)
 | `check` | query-only+ | SQL only (best on MySQL/MariaDB). |
 | `diff` | query-only+ | SQL only. Save/compare schema snapshots. |
 | `status` | query-only+ | Safe JSON/text summary (no credentials). |
-| `doctor` | n/a | Environment, config, connection, SRV diagnostics (Mongo), schema cache age; ES has a dedicated path. |
+| `doctor` | n/a | Environment, config, connection, SRV diagnostics (Mongo), schema cache age. |
 | `completion` | n/a | bash / zsh / fish scripts. |
 | `upgrade` | n/a | Self-update from npm; 24h-cached version hints on every command. |
-| `shell` | (same as query+) | Interactive REPL. SQL engines + MongoDB shell only; Redis/ES not currently exposed in REPL. |
-| `migrate` | admin | SQL only. **DDL; dry-run by default** — needs `--execute`; DROP also needs `--force`. Mongo/Redis exit with error. |
+| `shell` | (same as query+) | Interactive REPL. SQL engines + MongoDB shell only. |
+| `migrate` | admin | SQL only. **DDL; dry-run by default** — needs `--execute`. |
 
 `--use <name>` on any subcommand targets a v2 connection without changing the default.
 
@@ -71,29 +90,27 @@ dbcli query "SELECT * FROM users"   # Execute SQL (auto LIMIT 1000)
 - JSON filter object (`find`) or JSON array (`aggregate`); SQL is rejected. `--collection <name>` is required on `query`.
 - **Supported:** `init`, `list`, `schema` (sampled), `query`, `insert`, `update`, `delete`, `export`, `status`, `use`, `shell`, `doctor`, `upgrade`, `completion`.
 - **Not supported:** `q` (saved queries), `diff`, `migrate`, `check`.
-- Schema is **sampled** (default 50 docs, `--sample-size`); types are JS `typeof` strings — no PK/FK/index info.
-- `--limit` applies on `find`/aggregate; query-only mode caps at 1000 unless `--no-limit`.
+- Schema is **sampled** (default 50 docs); types are JS `typeof` strings.
 - See reference.md MongoDB section for full syntax and examples.
 
 ## Redis
 
 - Command-style execution; `query` runs a whitelisted Redis command (e.g. `GET`, `HSET`, `DEL`).
 - **Supported:** `init`, `list` (keys via SCAN), `schema <key>` (type / TTL / size / sample), `query`, `status`, `use`, `doctor`, `upgrade`, `completion`.
-- **Not supported:** `schema` full scan / `--refresh` / `--reset`, `insert`, `update`, `delete`, `export`, `check`, `diff`, `migrate`, `q`.
+- **Not supported:** `schema` full scan, `insert`, `update`, `delete`, `export`, `check`, `diff`, `migrate`, `q`.
   Use `query "DEL <key>"` etc. for writes — they go through the same permission gate.
-- Permission tiers map to commands: read commands → `query-only`; mutators (`SET`, `HSET`, `EXPIRE`, …) → `read-write`; `DEL` / `HDEL` / `UNLINK` → `data-admin`; `KEYS`, `FLUSHDB`, `CONFIG`, `INFO`, … → `admin`. Unlisted commands are denied.
+- Permission tiers map to commands: read commands → `query-only`; mutators (`SET`, `HSET`, ...) → `read-write`; `DEL` / `UNLINK` → `data-admin`.
 - `database` field is the logical DB index (default `0`); `list` returns ≤ 100 000 keys via SCAN.
 - See reference.md Redis section.
 
 ## Elasticsearch
 
-- DSL (JSON body) or Lucene query string; `--collection <index>` (or `--index <index>`) is required on `query`.
+- DSL (JSON body) or Lucene query string; `--collection <index>` is required on `query`.
 - **Supported:** `init`, `list` (indices with doc count), `schema [index]` (flattened mapping), `query`, `status`, `use`, `doctor`, `upgrade`, `completion`.
 - **Not supported:** `insert`, `update`, `delete`, `export`, `check`, `diff`, `migrate`, `q`.
-  Writes are not exposed via dedicated subcommands yet — use external tooling for indexing.
-- Auth: API key (`apiKey`), Basic (`user`/`password`), or Cloud ID (`cloudId`); supports HTTPS, custom CA (`caPath`), and multi-node arrays (`nodes`).
-- Query-only mode caps at 1000 hits; `--no-limit` is bounded at 10 000 (use saved searches with `search_after` beyond that).
-- Schema flattens nested fields (`a.b.c`) and surfaces `.fields` multi-fields (e.g. `text.keyword`).
+  Writes are not exposed via dedicated subcommands yet — use `query` if the cluster allows or external tools.
+- Query-only mode caps at 1000 hits; `--no-limit` is bounded at 10 000.
+- Schema flattens nested fields (`a.b.c`) and surfaces `.fields` multi-fields.
 - See reference.md Elasticsearch section.
 
 ## Saved queries

package/assets/reference.md

@@ -498,6 +498,33 @@ dbcli migrate drop-enum status --execute --force
 
 **AI agent note:** Always use dry-run first (no `--execute`) to preview generated SQL. Only add `--execute` after confirming the SQL is correct. For DROP operations, both `--execute` and `--force` are required.
 
+### skill tasks (Agent Task Packs)
+
+```bash
+dbcli skill tasks list                                            # human table
+dbcli skill tasks list --format json --tag diagnostics
+dbcli skill tasks list --engine postgres --source builtin
+dbcli skill tasks show diagnose-slow-query
+dbcli skill tasks show diagnose-slow-query --format json
+dbcli skill tasks plan diagnose-slow-query --param query="SELECT 1"
+dbcli skill tasks plan diagnose-slow-query --param query="..." --format json
+```
+
+- **list filters:** `--tag <tag>`, `--engine <postgres|mysql|mongodb|redis|elasticsearch>`, `--source <builtin|shared|local>`, `--format <table|json>`.
+- **show:** prints the full task definition (frontmatter + Agent Notes). Use `--format json` for an agent-friendly contract.
+- **plan:** resolves `{{param}}` placeholders, validates required parameters, and emits a stable plan. Plans are **plan-only** in this version — dbcli will never execute the resulting commands automatically.
+
+Task storage layers:
+
+| Source | Path | Notes |
+| --- | --- | --- |
+| builtin | `assets/tasks/` | shipped with dbcli |
+| shared | `.dbcli-shared/tasks/` | team-managed, version-controlled |
+| local | `.dbcli/tasks/` | personal, gitignored |
+
+Higher tiers override lower tiers by task name. Task name is derived from the
+file path under the tier root (e.g. `diag/inspect.md` → `diag/inspect`).
+
 ## MongoDB Support
 
 MongoDB connections use a JSON-based query model instead of SQL. Treat MongoDB support as a narrower document-database path, not as a full SQL feature equivalent.

package/assets/tasks/README.md

@@ -0,0 +1,30 @@
+# dbcli Agent Tasks (built-in)
+
+Built-in task templates shipped with dbcli for AI agents.
+
+## Resolution order
+
+```
+assets/tasks/             # builtin (lowest)
+.dbcli-shared/tasks/      # shared, version-controlled
+.dbcli/tasks/             # local, gitignored (highest)
+```
+
+A task with the same name in a higher tier overrides the lower one. Use this to
+customize built-in workflows without modifying dbcli source.
+
+## File format
+
+Each task is a `.md` file with a YAML frontmatter block:
+
+- `name` (required, must match the file path without `.md`)
+- `description`, `tags`, `engines`
+- `params` (map of name → `{ type, required?, default?, description?, enum? }`)
+- `safety.mode` — only `plan-only` is supported in this version
+- `steps[]` — each step is `{ type: command, command, reason?, risk? }`
+
+Use block-style YAML (no inline `{ ... }` maps) — the built-in YAML parser does
+not support inline maps.
+
+The markdown body below the frontmatter is `Agent Notes` and is shown in
+`dbcli skill tasks show <name>`.

package/assets/tasks/diagnose-slow-query.md

@@ -0,0 +1,33 @@
+---
+name: diagnose-slow-query
+description: Diagnose slow query causes using safe read-only dbcli steps.
+tags: [diagnostics, performance, readonly]
+engines: [postgres, mysql]
+params:
+  query:
+    type: string
+    required: true
+    description: The slow SQL query or query fingerprint to inspect.
+safety:
+  mode: plan-only
+  requires:
+    - blacklist-list
+    - schema-check
+steps:
+  - type: command
+    command: blacklist list
+    reason: Confirm sensitive tables and columns are protected before inspection.
+    risk: readonly
+  - type: command
+    command: plan "{{query}}"
+    reason: Analyze SQL risk without executing the query.
+    risk: readonly
+  - type: command
+    command: q @diag/long-running --format json
+    reason: Inspect active long-running queries through a saved diagnostic snippet.
+    risk: readonly
+---
+# Agent Notes
+
+Use this task when the user reports a slow SQL query and wants safe diagnostic next steps.
+Do not run write operations.

package/dist/cli.mjs

@@ -87311,38 +87311,97 @@ var init_types2 = __esm(() => {
 
 // src/core/saved-queries/yaml-mini.ts
 function parseYamlMini(text2) {
-  const lines2 = text2.split(`
-`).filter((l) => !/^\s*(#.*)?$/.test(l));
-  const root = {};
-  const stack = [{ indent: -1, node: root }];
-  for (const raw of lines2) {
+  const tokens = [];
+  for (const raw of text2.split(`
+`)) {
+    if (/^\s*(#.*)?$/.test(raw))
+      continue;
     if (raw.includes("\t")) {
       throw new Error(`YAML mini: tab indentation not supported: "${raw}"`);
     }
     const indent = raw.match(/^( *)/)[1].length;
-    const line = raw.slice(indent);
-    while (stack.length > 1 && indent <= stack[stack.length - 1].indent) {
-      stack.pop();
+    const lineBody = raw.slice(indent);
+    const isDash = lineBody === "-" || lineBody.startsWith("- ");
+    const content = isDash ? lineBody.slice(2).trim() : lineBody;
+    tokens.push({ indent, content, isDash, raw });
+  }
+  let i = 0;
+  function parseMapBlock(baseIndent) {
+    const map = {};
+    while (i < tokens.length && tokens[i].indent > baseIndent && !tokens[i].isDash) {
+      const tok = tokens[i];
+      consumeKeyValueInto(map, tok);
+    }
+    return map;
+  }
+  function parseListBlock(baseIndent) {
+    const list = [];
+    while (i < tokens.length && tokens[i].indent > baseIndent && tokens[i].isDash) {
+      const tok = tokens[i];
+      const itemIndent = tok.indent;
+      if (tok.content === "") {
+        i++;
+        if (i < tokens.length && tokens[i].indent > itemIndent) {
+          list.push(tokens[i].isDash ? parseListBlock(itemIndent) : parseMapBlock(itemIndent));
+        } else {
+          list.push(null);
+        }
+        continue;
+      }
+      const colonAt = colonOutsideBrackets(tok.content);
+      if (colonAt === -1) {
+        list.push(parseScalar(tok.content));
+        i++;
+        continue;
+      }
+      const itemMap = {};
+      consumeKeyValueInto(itemMap, tok);
+      while (i < tokens.length && tokens[i].indent > itemIndent && !tokens[i].isDash) {
+        consumeKeyValueInto(itemMap, tokens[i]);
+      }
+      list.push(itemMap);
     }
-    const parent = stack[stack.length - 1].node;
-    const colon = line.indexOf(":");
+    return list;
+  }
+  function consumeKeyValueInto(target, tok) {
+    const colon = colonOutsideBrackets(tok.content);
     if (colon === -1) {
-      throw new Error(`YAML mini: expected "key:" at "${raw}"`);
+      throw new Error(`YAML mini: expected "key:" at "${tok.raw}"`);
     }
-    const key2 = line.slice(0, colon).trim();
-    const rest = line.slice(colon + 1).trim();
+    const key2 = tok.content.slice(0, colon).trim();
+    const rest = tok.content.slice(colon + 1).trim();
     if (/^[&*]\w/.test(rest)) {
-      throw new Error(`YAML mini: anchor/reference unsupported: "${raw}"`);
+      throw new Error(`YAML mini: anchor/reference unsupported: "${tok.raw}"`);
     }
+    i++;
     if (rest === "") {
-      const child = {};
-      parent[key2] = child;
-      stack.push({ indent, node: child });
+      if (i < tokens.length && tokens[i].indent > tok.indent) {
+        if (tokens[i].isDash) {
+          target[key2] = parseListBlock(tok.indent);
+        } else {
+          target[key2] = parseMapBlock(tok.indent);
+        }
+      } else {
+        target[key2] = {};
+      }
     } else {
-      parent[key2] = parseScalarOrInlineList(rest);
+      target[key2] = parseScalarOrInlineList(rest);
     }
   }
-  return root;
+  return parseMapBlock(-1);
+}
+function colonOutsideBrackets(s) {
+  let depth = 0;
+  for (let k = 0;k < s.length; k++) {
+    const c = s[k];
+    if (c === "[" || c === "{")
+      depth++;
+    else if (c === "]" || c === "}")
+      depth--;
+    else if (c === ":" && depth === 0)
+      return k;
+  }
+  return -1;
 }
 function parseScalarOrInlineList(s) {
   if (s.startsWith("[") && s.endsWith("]")) {
@@ -88128,7 +88187,7 @@ var {
 // package.json
 var package_default = {
   name: "@carllee1983/dbcli",
-  version: "1.8.0",
+  version: "1.9.0",
   description: "Database CLI for AI agents",
   type: "module",
   publishConfig: {
@@ -95297,6 +95356,631 @@ async function ensureDir(dirPath) {
     }
   }
 }
+function registerSkillCommand(program2) {
+  return program2.command("skill").description(t("skill.description")).option("--install <platform>", "Install to platform directory (claude, gemini, copilot, cursor)").option("--output <path>", "Write skill to file instead of stdout").action(async (options) => {
+    try {
+      await skillCommand(program2, options);
+    } catch (error) {
+      console.error(error.message);
+      process.exit(1);
+    }
+  });
+}
+
+// src/core/agent-tasks/types.ts
+class AgentTaskError extends Error {
+  code;
+  file;
+  constructor(message, code, file) {
+    super(message);
+    this.code = code;
+    this.file = file;
+    this.name = "AgentTaskError";
+    Object.setPrototypeOf(this, AgentTaskError.prototype);
+  }
+}
+// src/core/agent-tasks/task-paths.ts
+import { join as join14, resolve as resolve4 } from "path";
+function resolveBuiltinDir2() {
+  return resolve4(import.meta.dir, "..", "..", "..", "assets", "tasks");
+}
+function resolveAgentTaskDirs(workspaceRoot) {
+  return {
+    builtinDir: resolveBuiltinDir2(),
+    sharedDir: join14(workspaceRoot, ".dbcli-shared", "tasks"),
+    localDir: join14(workspaceRoot, ".dbcli", "tasks")
+  };
+}
+// src/core/agent-tasks/parser.ts
+var VALID_ENGINES2 = ["postgres", "mysql", "mongodb", "redis", "elasticsearch"];
+var VALID_PARAM_TYPES = ["string", "number", "boolean"];
+var VALID_RISKS = ["readonly", "dry-run", "write", "unknown"];
+function parseAgentTask(input) {
+  const { frontmatter, body } = splitFrontmatter2(input.text, input.file);
+  if (!frontmatter.trim()) {
+    throw new AgentTaskError(`Task '${input.name}' has no frontmatter`, "PARSE_ERROR", input.file);
+  }
+  let raw;
+  try {
+    raw = parseYamlMini(frontmatter);
+  } catch (e) {
+    throw new AgentTaskError(`Invalid frontmatter in '${input.name}': ${e.message}`, "PARSE_ERROR", input.file);
+  }
+  const declaredName = raw.name;
+  if (typeof declaredName !== "string" || declaredName.trim() === "") {
+    throw new AgentTaskError(`Task '${input.name}' is missing required field 'name'`, "PARSE_ERROR", input.file);
+  }
+  if (declaredName !== input.name) {
+    throw new AgentTaskError(`Task name '${declaredName}' does not match expected '${input.name}' from filename`, "PARSE_ERROR", input.file);
+  }
+  const description = typeof raw.description === "string" ? raw.description : undefined;
+  const tags = Array.isArray(raw.tags) ? raw.tags.map(String) : [];
+  const engines = parseEngines(raw.engines, input);
+  const params = parseParams(raw.params, input);
+  const safety = parseSafety(raw.safety, input);
+  const steps = parseSteps(raw.steps, input);
+  const notes = body.trim() ? body.trim() : undefined;
+  return {
+    name: declaredName,
+    description,
+    tags,
+    engines,
+    params,
+    safety,
+    steps,
+    notes,
+    source: input.source,
+    file: input.file
+  };
+}
+function splitFrontmatter2(text2, file) {
+  const lines2 = text2.split(`
+`);
+  if (lines2[0]?.trim() !== "---")
+    return { frontmatter: "", body: text2 };
+  const end = lines2.findIndex((l, i) => i > 0 && l.trim() === "---");
+  if (end === -1) {
+    throw new AgentTaskError(`Unterminated frontmatter in ${file}`, "PARSE_ERROR", file);
+  }
+  return {
+    frontmatter: lines2.slice(1, end).join(`
+`),
+    body: lines2.slice(end + 1).join(`
+`)
+  };
+}
+function parseEngines(value, input) {
+  if (value === undefined || value === null)
+    return;
+  const list = Array.isArray(value) ? value : [value];
+  const cleaned = [];
+  for (const v of list) {
+    const s = String(v).toLowerCase();
+    if (!VALID_ENGINES2.includes(s)) {
+      throw new AgentTaskError(`Unknown engine '${s}' in task '${input.name}' (allowed: ${VALID_ENGINES2.join(", ")})`, "PARSE_ERROR", input.file);
+    }
+    cleaned.push(s);
+  }
+  return cleaned;
+}
+function parseParams(value, input) {
+  if (value === undefined || value === null)
+    return [];
+  if (typeof value !== "object" || Array.isArray(value)) {
+    throw new AgentTaskError(`'params' in task '${input.name}' must be a map`, "PARSE_ERROR", input.file);
+  }
+  return Object.entries(value).map(([name, spec]) => {
+    const type = String(spec?.type ?? "string");
+    if (!VALID_PARAM_TYPES.includes(type)) {
+      throw new AgentTaskError(`Param '${name}' in task '${input.name}': invalid type '${type}' (allowed: ${VALID_PARAM_TYPES.join(", ")})`, "PARSE_ERROR", input.file);
+    }
+    const hasDefault = spec && Object.prototype.hasOwnProperty.call(spec, "default");
+    const required = spec?.required === true ? true : !hasDefault && spec?.required !== false;
+    const out = { name, type, required };
+    if (typeof spec?.description === "string")
+      out.description = spec.description;
+    if (hasDefault)
+      out.default = spec.default;
+    if (Array.isArray(spec?.enum))
+      out.enum = spec.enum;
+    return out;
+  });
+}
+function parseSafety(value, input) {
+  if (!value || typeof value !== "object") {
+    throw new AgentTaskError(`Task '${input.name}' is missing required field 'safety'`, "PARSE_ERROR", input.file);
+  }
+  const obj = value;
+  if (obj.mode !== "plan-only") {
+    throw new AgentTaskError(`Task '${input.name}' has invalid safety.mode '${String(obj.mode)}' (only 'plan-only' is supported)`, "PARSE_ERROR", input.file);
+  }
+  const requires = Array.isArray(obj.requires) ? obj.requires.map(String) : undefined;
+  return requires ? { mode: "plan-only", requires } : { mode: "plan-only" };
+}
+function parseSteps(value, input) {
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new AgentTaskError(`Task '${input.name}' must declare at least one step`, "PARSE_ERROR", input.file);
+  }
+  return value.map((raw, idx) => {
+    if (!raw || typeof raw !== "object") {
+      throw new AgentTaskError(`Task '${input.name}' step #${idx + 1} is not an object`, "PARSE_ERROR", input.file);
+    }
+    const obj = raw;
+    if (obj.type !== "command") {
+      throw new AgentTaskError(`Task '${input.name}' step #${idx + 1} has unsupported type '${String(obj.type)}' (only 'command' is supported)`, "PARSE_ERROR", input.file);
+    }
+    if (typeof obj.command !== "string" || obj.command.trim() === "") {
+      throw new AgentTaskError(`Task '${input.name}' step #${idx + 1} is missing 'command'`, "PARSE_ERROR", input.file);
+    }
+    const risk = obj.risk === undefined ? undefined : String(obj.risk);
+    if (risk !== undefined && !VALID_RISKS.includes(risk)) {
+      throw new AgentTaskError(`Task '${input.name}' step #${idx + 1} has invalid risk '${risk}'`, "PARSE_ERROR", input.file);
+    }
+    const step = { type: "command", command: obj.command.trim() };
+    if (typeof obj.reason === "string")
+      step.reason = obj.reason;
+    if (risk !== undefined)
+      step.risk = risk;
+    return step;
+  });
+}
+// src/core/agent-tasks/loader.ts
+import { readdir as readdir2 } from "fs/promises";
+import { join as join15, relative as relative2, sep as sep2 } from "path";
+async function loadAgentTasks(opts, flags) {
+  const errors3 = [];
+  const builtin = await walkAndParse2(opts.builtinDir, "builtin", errors3);
+  const shared = await walkAndParse2(opts.sharedDir, "shared", errors3);
+  const local = await walkAndParse2(opts.localDir, "local", errors3);
+  const merged = new Map;
+  for (const t2 of builtin)
+    merged.set(t2.name, { task: t2, hasOverride: false });
+  for (const t2 of shared) {
+    const had = merged.has(t2.name);
+    merged.set(t2.name, { task: t2, hasOverride: had });
+  }
+  for (const t2 of local) {
+    const had = merged.has(t2.name);
+    merged.set(t2.name, { task: t2, hasOverride: had });
+  }
+  Object.defineProperty(merged, "errors", {
+    value: flags?.collectErrors ? errors3 : [],
+    enumerable: false,
+    writable: false
+  });
+  return merged;
+}
+async function walkAndParse2(root, source, errors3) {
+  const files = await safeCollectMd(root);
+  const out = [];
+  for (const file of files) {
+    const rel = relative2(root, file).split(sep2).join("/");
+    if (!rel.endsWith(".md"))
+      continue;
+    if (rel.toLowerCase() === "readme.md")
+      continue;
+    const name = rel.slice(0, -".md".length);
+    try {
+      const text2 = await Bun.file(file).text();
+      const task = parseAgentTask({ name, file, source, text: text2 });
+      out.push(task);
+    } catch (e) {
+      if (e instanceof AgentTaskError)
+        errors3.push(e);
+      else
+        errors3.push(new AgentTaskError(e.message, "IO_ERROR", file));
+    }
+  }
+  return out;
+}
+async function safeCollectMd(root) {
+  const out = [];
+  async function walk(dir) {
+    let entries;
+    try {
+      entries = await readdir2(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      const full = join15(dir, e.name);
+      if (e.isDirectory())
+        await walk(full);
+      else
+        out.push(full);
+    }
+  }
+  await walk(root);
+  return out;
+}
+// src/core/agent-tasks/resolver.ts
+function filterTasks(map, opts) {
+  return [...map.values()].filter((entry) => {
+    const t2 = entry.task;
+    if (opts.tag && !t2.tags.includes(opts.tag))
+      return false;
+    if (opts.engine) {
+      const declared = t2.engines;
+      if (declared && declared.length > 0 && !declared.includes(opts.engine))
+        return false;
+    }
+    if (opts.source && t2.source !== opts.source)
+      return false;
+    return true;
+  });
+}
+function resolveTaskByName(map, name) {
+  const direct = map.get(name);
+  if (direct)
+    return direct;
+  const suggestions = suggestSimilar2([...map.keys()], name);
+  const hint = suggestions.length > 0 ? `
+  Did you mean: ${suggestions.join(", ")}?` : "";
+  throw new AgentTaskError(`Task not found: ${name}${hint}`, "NOT_FOUND");
+}
+function suggestSimilar2(all, name, limit = 5) {
+  return all.map((k) => ({ k, d: levenshteinDistance(k, name) })).sort((a, b) => a.d - b.d).slice(0, limit).map((x) => x.k);
+}
+// src/core/agent-tasks/argv-split.ts
+function splitArgv(input) {
+  const out = [];
+  let current = "";
+  let inSingle = false;
+  let inDouble = false;
+  let hasToken = false;
+  for (let i = 0;i < input.length; i++) {
+    const ch = input[i];
+    if (inSingle) {
+      if (ch === "'") {
+        inSingle = false;
+      } else {
+        current += ch;
+        hasToken = true;
+      }
+      continue;
+    }
+    if (inDouble) {
+      if (ch === "\\" && (input[i + 1] === '"' || input[i + 1] === "\\")) {
+        current += input[i + 1];
+        i++;
+        hasToken = true;
+        continue;
+      }
+      if (ch === '"') {
+        inDouble = false;
+      } else {
+        current += ch;
+        hasToken = true;
+      }
+      continue;
+    }
+    if (ch === "'") {
+      inSingle = true;
+      hasToken = true;
+      continue;
+    }
+    if (ch === '"') {
+      inDouble = true;
+      hasToken = true;
+      continue;
+    }
+    if (ch === "\\" && i + 1 < input.length) {
+      current += input[i + 1];
+      i++;
+      hasToken = true;
+      continue;
+    }
+    if (ch === " " || ch === "\t" || ch === `
+`) {
+      if (hasToken) {
+        out.push(current);
+        current = "";
+        hasToken = false;
+      }
+      continue;
+    }
+    current += ch;
+    hasToken = true;
+  }
+  if (inSingle || inDouble) {
+    throw new Error(`Unterminated quote in command: ${input}`);
+  }
+  if (hasToken)
+    out.push(current);
+  return out;
+}
+
+// src/core/agent-tasks/planner.ts
+var TEMPLATE_RE = /\{\{\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\}\}/g;
+function planAgentTask(input) {
+  const warnings = [];
+  const resolved = resolveParams(input.task.params, input.params, warnings);
+  const steps = input.task.steps.map((step) => {
+    const resolvedCommand = applyTemplate(step.command, resolved, input.task);
+    const argv = splitArgv(resolvedCommand);
+    const out = {
+      command: step.command,
+      resolvedCommand,
+      argv
+    };
+    if (step.reason)
+      out.reason = step.reason;
+    if (step.risk)
+      out.risk = step.risk;
+    return out;
+  });
+  return {
+    name: input.task.name,
+    source: input.task.source,
+    file: input.task.file,
+    description: input.task.description,
+    mode: input.task.safety.mode,
+    requires: input.task.safety.requires ?? [],
+    parameters: resolved,
+    steps,
+    warnings
+  };
+}
+function resolveParams(spec, provided, warnings) {
+  const out = {};
+  const knownNames = new Set(spec.map((p) => p.name));
+  for (const p of spec) {
+    const raw = provided[p.name];
+    if (raw === undefined || raw === "") {
+      if (p.default !== undefined) {
+        out[p.name] = p.default;
+        continue;
+      }
+      if (p.required) {
+        throw new AgentTaskError(`Missing required parameter '${p.name}'`, "PARAM_MISSING");
+      }
+      continue;
+    }
+    out[p.name] = coerce2(p, raw);
+  }
+  for (const key2 of Object.keys(provided)) {
+    if (!knownNames.has(key2)) {
+      warnings.push(`Unknown parameter '${key2}' (ignored)`);
+    }
+  }
+  return out;
+}
+function coerce2(p, raw) {
+  let value;
+  if (p.type === "number") {
+    const n = typeof raw === "number" ? raw : Number(raw);
+    if (!Number.isFinite(n)) {
+      throw new AgentTaskError(`Parameter '${p.name}' must be a number (got '${raw}')`, "PARAM_INVALID");
+    }
+    value = n;
+  } else if (p.type === "boolean") {
+    if (typeof raw === "boolean")
+      value = raw;
+    else if (raw === "true")
+      value = true;
+    else if (raw === "false")
+      value = false;
+    else
+      throw new AgentTaskError(`Parameter '${p.name}' must be a boolean (got '${raw}')`, "PARAM_INVALID");
+  } else {
+    value = String(raw);
+  }
+  if (p.enum && !p.enum.includes(value)) {
+    throw new AgentTaskError(`Parameter '${p.name}' must match enum [${p.enum.join(", ")}] (got '${value}')`, "PARAM_INVALID");
+  }
+  return value;
+}
+function applyTemplate(command, values, task) {
+  return command.replace(TEMPLATE_RE, (_match, key2) => {
+    if (!(key2 in values)) {
+      throw new AgentTaskError(`Template references unknown parameter '${key2}' in task '${task.name}'`, "TEMPLATE_SYNTAX", task.file);
+    }
+    return String(values[key2]);
+  });
+}
+function renderMarkdownPlan(plan) {
+  const lines2 = [];
+  lines2.push(`# Task: ${plan.name}`);
+  if (plan.description)
+    lines2.push("", plan.description);
+  lines2.push("", `- **source**: ${plan.source}`);
+  lines2.push(`- **file**: ${plan.file}`);
+  lines2.push(`- **mode**: ${plan.mode}`);
+  if (plan.requires.length > 0) {
+    lines2.push(`- **requires**: ${plan.requires.join(", ")}`);
+  }
+  lines2.push("", "## Parameters");
+  if (Object.keys(plan.parameters).length === 0) {
+    lines2.push("_(none)_");
+  } else {
+    for (const [k, v] of Object.entries(plan.parameters)) {
+      lines2.push(`- ${k}: ${String(v)}`);
+    }
+  }
+  lines2.push("", "## Steps");
+  plan.steps.forEach((s, i) => {
+    lines2.push(`### ${i + 1}. \`${s.resolvedCommand}\``);
+    if (s.risk)
+      lines2.push(`- risk: ${s.risk}`);
+    if (s.reason)
+      lines2.push(`- reason: ${s.reason}`);
+    if (s.command !== s.resolvedCommand) {
+      lines2.push(`- template: \`${s.command}\``);
+    }
+    lines2.push("");
+  });
+  if (plan.warnings.length > 0) {
+    lines2.push("## Warnings");
+    for (const w of plan.warnings)
+      lines2.push(`- ${w}`);
+  }
+  return lines2.join(`
+`);
+}
+// src/commands/skill-tasks.ts
+function registerSkillTasksCommand(parent) {
+  const tasks = parent.command("tasks").description("Discover and plan AI-agent task templates");
+  tasks.command("list").description("List available agent task templates").option("--format <type>", "Output format: table | json", "table").option("--tag <tag>", "Filter by tag").option("--engine <engine>", "Filter by engine: postgres | mysql | mongodb | redis | elasticsearch").option("--source <source>", "Filter by source: builtin | shared | local").action(async (options) => {
+    try {
+      await runList(options);
+    } catch (e) {
+      console.error(e.message);
+      process.exit(1);
+    }
+  });
+  tasks.command("show <task>").description("Show full task definition and notes").option("--format <type>", "Output format: markdown | json", "markdown").action(async (taskName, options) => {
+    try {
+      await runShow(taskName, options);
+    } catch (e) {
+      console.error(e.message);
+      process.exit(1);
+    }
+  });
+  tasks.command("plan <task>").description("Generate an executable plan for a task (no execution)").option("--format <type>", "Output format: markdown | json", "markdown").option("--param <kv>", "Pass parameter as key=value (repeatable)", (val, prev = []) => prev.concat([val]), []).action(async (taskName, options) => {
+    try {
+      await runPlan(taskName, options);
+    } catch (e) {
+      console.error(e.message);
+      process.exit(1);
+    }
+  });
+  return tasks;
+}
+async function runList(options) {
+  const map = await loadAgentTasks(resolveAgentTaskDirs(process.cwd()));
+  const filtered = filterTasks(map, {
+    tag: options.tag,
+    engine: options.engine,
+    source: options.source
+  });
+  if (options.format === "json") {
+    const json = filtered.map((entry) => ({
+      name: entry.task.name,
+      description: entry.task.description,
+      source: entry.task.source,
+      tags: entry.task.tags,
+      engines: entry.task.engines,
+      hasOverride: entry.hasOverride || undefined,
+      params: entry.task.params.map((p) => ({
+        name: p.name,
+        type: p.type,
+        ...p.required ? { required: true } : {},
+        ...p.default !== undefined ? { default: p.default } : {}
+      })),
+      file: entry.task.file
+    }));
+    console.log(JSON.stringify(json, null, 2));
+    return;
+  }
+  if (filtered.length === 0) {
+    console.log("No agent tasks found.");
+    return;
+  }
+  const header = ["NAME", "SOURCE", "ENGINES", "TAGS", "DESCRIPTION"];
+  const rows = filtered.map((entry) => [
+    entry.task.name + (entry.hasOverride ? "*" : ""),
+    entry.task.source,
+    (entry.task.engines ?? []).join(",") || "-",
+    entry.task.tags.join(",") || "-",
+    entry.task.description ?? ""
+  ]);
+  const widths = header.map((h, i) => Math.max(h.length, ...rows.map((r) => (r[i] ?? "").length)));
+  const fmt = (line) => line.map((c, i) => (c ?? "").padEnd(widths[i] ?? 0)).join("  ");
+  console.log(fmt(header));
+  for (const r of rows)
+    console.log(fmt(r));
+}
+async function runShow(taskName, options) {
+  const map = await loadAgentTasks(resolveAgentTaskDirs(process.cwd()));
+  const entry = resolveTaskByName(map, taskName);
+  const task = entry.task;
+  if (options.format === "json") {
+    console.log(JSON.stringify({
+      name: task.name,
+      description: task.description,
+      source: task.source,
+      file: task.file,
+      tags: task.tags,
+      engines: task.engines,
+      params: task.params,
+      safety: task.safety,
+      steps: task.steps,
+      notes: task.notes
+    }, null, 2));
+    return;
+  }
+  console.log(`# ${task.name} (${task.source})`);
+  if (task.description)
+    console.log(task.description);
+  console.log("");
+  console.log(`- file: ${task.file}`);
+  if (task.engines)
+    console.log(`- engines: ${task.engines.join(", ")}`);
+  if (task.tags.length > 0)
+    console.log(`- tags: ${task.tags.join(", ")}`);
+  console.log(`- safety: ${task.safety.mode}`);
+  if (task.safety.requires?.length) {
+    console.log(`- requires: ${task.safety.requires.join(", ")}`);
+  }
+  if (task.params.length > 0) {
+    console.log(`
+## Parameters`);
+    for (const p of task.params) {
+      const def = p.default !== undefined ? ` (default: ${p.default})` : "";
+      const req = p.required ? " (required)" : "";
+      console.log(`- ${p.name}: ${p.type}${req}${def}`);
+      if (p.description)
+        console.log(`    ${p.description}`);
+    }
+  }
+  console.log(`
+## Steps`);
+  task.steps.forEach((s, i) => {
+    console.log(`${i + 1}. \`${s.command}\``);
+    if (s.reason)
+      console.log(`   reason: ${s.reason}`);
+    if (s.risk)
+      console.log(`   risk: ${s.risk}`);
+  });
+  if (task.notes) {
+    console.log(`
+## Notes
+`);
+    console.log(task.notes);
+  }
+}
+async function runPlan(taskName, options) {
+  const map = await loadAgentTasks(resolveAgentTaskDirs(process.cwd()));
+  const entry = resolveTaskByName(map, taskName);
+  const params = parseParamPairs(options.param ?? []);
+  const plan = planAgentTask({ task: entry.task, params });
+  if (options.format === "json") {
+    console.log(JSON.stringify({
+      name: plan.name,
+      source: plan.source,
+      file: plan.file,
+      description: plan.description,
+      mode: plan.mode,
+      requires: plan.requires,
+      parameters: plan.parameters,
+      steps: plan.steps,
+      warnings: plan.warnings
+    }, null, 2));
+    return;
+  }
+  console.log(renderMarkdownPlan(plan));
+}
+function parseParamPairs(pairs) {
+  const out = {};
+  for (const p of pairs) {
+    const eq = p.indexOf("=");
+    if (eq === -1) {
+      throw new Error(`Invalid --param '${p}' (expected key=value)`);
+    }
+    out[p.slice(0, eq).trim()] = p.slice(eq + 1);
+  }
+  return out;
+}
 
 // src/commands/blacklist.ts
 var DEFAULT_CONFIG_PATH = ".dbcli";
@@ -95847,7 +96531,7 @@ var statusCommand = new Command("status").description("Show current configuratio
 // src/commands/doctor.ts
 init_validation();
 init_schema_path();
-import { join as join14 } from "path";
+import { join as join16 } from "path";
 import { resolveSrv as resolveSrv2 } from "dns/promises";
 var ALLOWED_FORMATS8 = ["text", "json"];
 var SENSITIVE_PATTERNS = [
@@ -95921,7 +96605,7 @@ var runDoctorChecks = {
     }
   },
   async checkConfigExists(configPath, existsFn) {
-    const exists = existsFn ? await existsFn(configPath) : await Bun.file(configPath).exists() || await Bun.file(join14(configPath, "config.json")).exists();
+    const exists = existsFn ? await existsFn(configPath) : await Bun.file(configPath).exists() || await Bun.file(join16(configPath, "config.json")).exists();
     return {
       group: "Configuration",
       label: "Config exists",
@@ -96078,7 +96762,7 @@ var runDoctorChecks = {
   async checkV2Config(configPath) {
     const results = [];
     const storagePath = await resolveConfigStoragePath(configPath);
-    const configFile = Bun.file(join14(storagePath, "config.json"));
+    const configFile = Bun.file(join16(storagePath, "config.json"));
     if (!await configFile.exists())
       return results;
     let raw;
@@ -96118,7 +96802,7 @@ var runDoctorChecks = {
     }
     for (const [name, conn] of Object.entries(config.connections)) {
       if (conn.envFile) {
-        const envPath = join14(storagePath, conn.envFile);
+        const envPath = join16(storagePath, conn.envFile);
         const exists = await Bun.file(envPath).exists();
         results.push({
           group: "Configuration",
@@ -96337,7 +97021,7 @@ var doctorCommand = new Command("doctor").description("Run diagnostic checks on
           }
           try {
             const schemaConnName = await getSchemaIsolationConnectionName(configPath);
-            const indexPath = join14(resolveSchemaPath(storagePath, schemaConnName), "index.json");
+            const indexPath = join16(resolveSchemaPath(storagePath, schemaConnName), "index.json");
             const indexFile = Bun.file(indexPath);
             let indexParsed = null;
             if (await indexFile.exists()) {
@@ -96379,7 +97063,7 @@ var doctorCommand = new Command("doctor").description("Run diagnostic checks on
 });
 
 // src/commands/completion.ts
-import { join as join15 } from "path";
+import { join as join17 } from "path";
 import { homedir as homedir3 } from "os";
 function extractCommands(program2) {
   return program2.commands.map((cmd) => ({
@@ -96481,11 +97165,11 @@ function getInstallPath2(shell) {
   const home = homedir3();
   switch (shell) {
     case "bash":
-      return join15(home, ".bashrc");
+      return join17(home, ".bashrc");
     case "zsh":
-      return join15(home, ".zshrc");
+      return join17(home, ".zshrc");
     case "fish":
-      return join15(home, ".config", "fish", "completions", "dbcli.fish");
+      return join17(home, ".config", "fish", "completions", "dbcli.fish");
     default:
       throw new Error(`Unsupported shell: ${shell}. Supported: bash, zsh, fish`);
   }
@@ -96505,7 +97189,7 @@ var MARKER_END = "# <<< dbcli completion <<<";
 async function installCompletion(shell, script) {
   const targetPath = getInstallPath2(shell);
   if (shell === "fish") {
-    const dir = join15(homedir3(), ".config", "fish", "completions");
+    const dir = join17(homedir3(), ".config", "fish", "completions");
     await Bun.$`mkdir -p ${dir}`.quiet();
     await Bun.file(targetPath).write(script);
     console.log(colors.success(`\u2713 Fish completion installed to ${targetPath}`));
@@ -96732,7 +97416,7 @@ ${t("upgrade.failed")}`));
 
 // src/commands/shell.ts
 import { createInterface as createInterface2 } from "readline";
-import { join as join16 } from "path";
+import { join as join18 } from "path";
 import { homedir as homedir4 } from "os";
 
 // src/core/repl/types.ts
@@ -97455,7 +98139,7 @@ class MongoShellAdapter {
 }
 
 // src/commands/shell.ts
-var HISTORY_PATH = join16(homedir4(), ".dbcli_history");
+var HISTORY_PATH = join18(homedir4(), ".dbcli_history");
 var MONGO_COMPLETION_EAGER_THRESHOLD = 20;
 async function populateMongoColumns(mongoAdapter, collectionNames, threshold = MONGO_COMPLETION_EAGER_THRESHOLD) {
   const columnsByTable = {};
@@ -98426,7 +99110,7 @@ addExecOpts(migrateCommand.command("drop-enum <name>").description(t("migrate.dr
 });
 
 // src/commands/use.ts
-import { join as join17 } from "path";
+import { join as join19 } from "path";
 async function switchDefault(configPath, name, config) {
   if (!config.connections[name]) {
     const available = Object.keys(config.connections).join(", ");
@@ -98449,7 +99133,7 @@ function listConnectionsForDisplay(config) {
 }
 async function ensureV2Config(configPath) {
   const storagePath = await resolveConfigStoragePath(configPath);
-  const configFile = Bun.file(join17(storagePath, "config.json"));
+  const configFile = Bun.file(join19(storagePath, "config.json"));
   const legacyFile = Bun.file(configPath);
   if (!await configFile.exists() && !await legacyFile.exists()) {
     throw new ConfigError(t("init.config_not_found"));
@@ -98511,7 +99195,7 @@ var useCommand = new Command("use").description("Switch or display the default d
 });
 
 // src/cli.ts
-import { join as join18 } from "path";
+import { join as join20 } from "path";
 var _bgVersionCheckResult;
 function shouldSkipBackgroundChecks() {
   return process.env.DBCLI_NO_UPDATE_CHECK === "1" || process.env.DBCLI_NO_UPDATE_CHECK === "true" || false;
@@ -98540,7 +99224,7 @@ program2.hook("preAction", (thisCommand, actionCommand) => {
       try {
         let cache = null;
         try {
-          const cacheFile = Bun.file(join18(configPath, "version-check.json"));
+          const cacheFile = Bun.file(join20(configPath, "version-check.json"));
           if (await cacheFile.exists()) {
             cache = await cacheFile.json();
           }
@@ -98618,14 +99302,8 @@ program2.command("export <sql>").description(t("export.description")).option("--
     process.exit(1);
   }
 });
-program2.command("skill").description(t("skill.description")).option("--install <platform>", "Install to platform directory (claude, gemini, copilot, cursor)").option("--output <path>", "Write skill to file instead of stdout").action(async (options) => {
-  try {
-    await skillCommand(program2, options);
-  } catch (error) {
-    console.error(error.message);
-    process.exit(1);
-  }
-});
+var skillCmd = registerSkillCommand(program2);
+registerSkillTasksCommand(skillCmd);
 program2.addCommand(blacklistCommand);
 program2.addCommand(checkCommand);
 program2.addCommand(diffCommand);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@carllee1983/dbcli",
-  "version": "1.8.0",
+  "version": "1.9.0",
   "description": "Database CLI for AI agents",
   "type": "module",
   "publishConfig": {