@yugabytedb/meko-mcp 1.2.0 → 2.1.0

package/assets/hooks-handlers/lib/checkpoint-timer.js

@@ -12,16 +12,29 @@
  *
  * Environment:
  *   MEKO_CHECKPOINT_INTERVAL  Seconds between ticks (default: 600)
+ *   MEKO_TIMER_MAX_AGE        Hard self-exit age in seconds (default: 86400 = 24h)
+ *   MEKO_TIMER_IDLE_EXIT      Self-exit after the transcript is untouched this
+ *                             long, in seconds (default: 7200 = 2h)
+ *   MEKO_TIMER_STARTUP_GRACE  Wait this long for the transcript to appear
+ *                             before self-exiting (default: 1800 = 30min)
  *   MEKO_WATERMARK_DIR        Watermark directory (default: ~/.claude/meko-capture)
  *   MEKO_MCP_URL              Inherited by capture.js
  *   MEKO_API_KEY              Inherited by capture.js
  */
 
-const { execFileSync } = require("child_process");
+const { execFile } = require("child_process");
 const fs = require("fs");
 const path = require("path");
 
 const INTERVAL_SECS = parseInt(process.env.MEKO_CHECKPOINT_INTERVAL || "600", 10);
+// Self-exit backstops so an orphaned daemon (its pid file removed out of band,
+// a missed SessionEnd, a blocked SIGTERM) cannot tick forever. Both are
+// generous enough not to interrupt a genuinely long, active session.
+const MAX_AGE_SECS = parseInt(process.env.MEKO_TIMER_MAX_AGE, 10) || 86400;
+const IDLE_EXIT_SECS = parseInt(process.env.MEKO_TIMER_IDLE_EXIT, 10) || 7200;
+const STARTUP_GRACE_SECS =
+  parseInt(process.env.MEKO_TIMER_STARTUP_GRACE, 10) || 1800;
+const startedAt = Date.now();
 const WATERMARK_DIR =
   process.env.MEKO_WATERMARK_DIR ||
   path.join(process.env.HOME || "~", ".claude", "meko-capture");
@@ -49,24 +62,65 @@ process.on("SIGTERM", cleanup);
 process.on("SIGINT", cleanup);
 
 function tick() {
-  // Skip if transcript doesn't exist (session ended but we weren't killed yet)
-  if (!fs.existsSync(transcriptPath)) {
+  // Self-exit backstop: never outlive the hard max age. Guards against orphans
+  // whose pid file was removed out of band (so session-end.sh can't kill them)
+  // or whose SessionEnd never fired (force-quit / terminal closed).
+  if (Date.now() - startedAt >= MAX_AGE_SECS * 1000) {
+    process.stderr.write(
+      `[meko-timer] Max age (${MAX_AGE_SECS}s) reached; self-exiting to avoid orphan.\n`,
+    );
     cleanup();
     return;
   }
 
-  const hookInput = JSON.stringify({ transcript_path: transcriptPath });
-
+  // Exit if the transcript is gone (session ended but we weren't killed yet).
+  // SessionStart can precede transcript creation by up to 20 minutes, so a
+  // missing file during the startup grace period is expected.
+  let stat;
   try {
-    execFileSync("node", [captureScript, "checkpoint"], {
-      input: hookInput,
-      timeout: 30000,
-      stdio: ["pipe", "pipe", "pipe"],
-    });
-  } catch (err) {
-    // Best-effort: log and continue
-    process.stderr.write(`[meko-timer] Checkpoint tick failed: ${err.message}\n`);
+    stat = fs.statSync(transcriptPath);
+  } catch {
+    if (Date.now() - startedAt < STARTUP_GRACE_SECS * 1000) {
+      return;
+    }
+    cleanup();
+    return;
   }
+
+  // Exit if the transcript has been idle far longer than a checkpoint window —
+  // the session is effectively over even though we were never signalled.
+  if (Date.now() - stat.mtimeMs >= IDLE_EXIT_SECS * 1000) {
+    process.stderr.write(
+      `[meko-timer] Transcript idle > ${IDLE_EXIT_SECS}s; self-exiting.\n`,
+    );
+    cleanup();
+    return;
+  }
+
+  const hookInput = JSON.stringify({ transcript_path: transcriptPath });
+
+  // Run capture ASYNCHRONOUSLY. execFileSync would block this daemon's event
+  // loop for up to 30s, during which SIGTERM/SIGINT (clean shutdown) can't be
+  // handled. execFile keeps the loop responsive so cleanup() fires promptly.
+  const child = execFile(
+    "node",
+    [captureScript, "checkpoint"],
+    { timeout: 30000 },
+    (err) => {
+      if (err) {
+        // Best-effort: log and continue to the next tick.
+        process.stderr.write(`[meko-timer] Checkpoint tick failed: ${err.message}\n`);
+      }
+    },
+  );
+  // The stdin stream can emit EPIPE if the child exits or fails to spawn before
+  // we finish writing. Without a listener that error is unhandled and crashes
+  // the daemon — so swallow it here; the execFile callback above reports the
+  // real failure.
+  child.stdin.on("error", (err) => {
+    process.stderr.write(`[meko-timer] Checkpoint stdin error: ${err.message}\n`);
+  });
+  child.stdin.end(hookInput);
 }
 
 setInterval(tick, INTERVAL_SECS * 1000);

package/assets/hooks-handlers/session-end.sh

@@ -21,6 +21,16 @@ if [ -n "$TRANSCRIPT_PATH" ]; then
     kill "$(cat "$PID_FILE")" 2>/dev/null || true
     rm -f "$PID_FILE"
   fi
+  # Fallback: the pid file can go missing while the daemon lives (removed out of
+  # band, a missed/blocked signal). Match the running checkpoint-timer.js by the
+  # clean session id rather than the absolute transcript path, which may contain
+  # regex metacharacters that make pgrep fail or match incorrectly.
+  if command -v pgrep >/dev/null 2>&1; then
+    for pid in $(pgrep -f "checkpoint-timer.js .*${SESSION_ID}" 2>/dev/null); do
+      [ "$pid" = "$$" ] && continue
+      kill "$pid" 2>/dev/null || true
+    done
+  fi
 fi
 
 # Run final capture

package/assets/hooks-handlers/session-start.sh

@@ -13,10 +13,21 @@ TRANSCRIPT_PATH="$(printf '%s' "$HOOK_INPUT" | node -e '
   process.stdout.write(p);
 ' 2>/dev/null)"
 
-# Spawn background checkpoint timer (periodic capture without interrupting the agent)
-if [ -n "$TRANSCRIPT_PATH" ] && [ -f "$TRANSCRIPT_PATH" ]; then
+# Spawn background checkpoint timer (periodic capture without interrupting the agent).
+# Send the daemon's stderr to a log file instead of /dev/null so startup
+# failures and crashes are diagnosable; stdout is still discarded.
+#
+# NOTE: we deliberately do NOT gate on [ -f "$TRANSCRIPT_PATH" ]. SessionStart
+# fires before Claude Code writes the transcript .jsonl, so that file usually
+# does not exist yet at hook time (measured gaps of +3s to +20min). Gating on
+# its existence meant the timer never spawned and the whole session went
+# uncaptured. checkpoint-timer.js self-guards a missing transcript on each
+# tick(), so spawning unconditionally (when the path is known) is safe.
+if [ -n "$TRANSCRIPT_PATH" ]; then
+  MEKO_LOG_DIR="${MEKO_WATERMARK_DIR:-$HOME/.claude/meko-capture}"
+  mkdir -p "$MEKO_LOG_DIR"
   nohup node "$SCRIPT_DIR/lib/checkpoint-timer.js" "$TRANSCRIPT_PATH" \
-    </dev/null >/dev/null 2>&1 &
+    </dev/null >/dev/null 2>>"$MEKO_LOG_DIR/timer.log" &
   disown 2>/dev/null || true
 fi
 

package/assets/hooks-handlers/test_checkpoint_timer.sh

@@ -0,0 +1,162 @@
+#!/usr/bin/env bash
+#
+# test_checkpoint_timer.sh — Regression tests for issue #159:
+#   - Defect 1: the checkpoint timer must spawn even when the transcript file
+#     does not exist yet at SessionStart time (spawn race).
+#   - Defect 3: the timer must self-exit (max-age / idle backstop) and
+#     session-end.sh must kill it by transcript path when the pid file is gone,
+#     so orphaned daemons cannot tick forever.
+#
+# These tests do NOT require a live Meko MCP server: the timer's self-guard and
+# self-exit paths run before any capture.js checkpoint would reach MCP, and we
+# assert on process liveness / pid-file presence only.
+#
+# Usage: ./test_checkpoint_timer.sh
+
+set -uo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+TIMER_JS="$SCRIPT_DIR/lib/checkpoint-timer.js"
+SESSION_START="$SCRIPT_DIR/session-start.sh"
+SESSION_END="$SCRIPT_DIR/session-end.sh"
+
+WM_DIR="$(mktemp -d -t meko-timer-test-XXXXXX)"
+TX_ROOT="$(mktemp -d -t meko-timer-tx-XXXXXX)"
+# Exercise session-end matching when the absolute transcript path contains
+# characters that have special meaning in a regular expression.
+TX_DIR="$TX_ROOT/path with [regex] chars"
+mkdir -p "$TX_DIR"
+SESSION_ID="timer-test-$$"
+TRANSCRIPT_PATH="$TX_DIR/${SESSION_ID}.jsonl"
+PID_FILE="$WM_DIR/${SESSION_ID}.timer.pid"
+
+PASS=0
+FAIL=0
+SPAWNED_PIDS=()
+
+cleanup() {
+  for p in "${SPAWNED_PIDS[@]:-}"; do kill "$p" 2>/dev/null || true; done
+  rm -rf "$WM_DIR" "$TX_ROOT"
+}
+trap cleanup EXIT
+
+log()  { printf "  %-55s" "$1"; }
+pass() { printf "\033[32mPASS\033[0m %s\n" "${1:-}"; PASS=$((PASS + 1)); }
+fail() { printf "\033[31mFAIL\033[0m %s\n" "${1:-}"; FAIL=$((FAIL + 1)); }
+
+# Poll up to N deciseconds for a process to die. Returns 0 if it died.
+wait_gone() {
+  local pid="$1" tries="${2:-50}"
+  while [ "$tries" -gt 0 ]; do
+    kill -0 "$pid" 2>/dev/null || return 0
+    sleep 0.1
+    tries=$((tries - 1))
+  done
+  return 1
+}
+
+export MEKO_WATERMARK_DIR="$WM_DIR"
+
+echo "============================================================"
+echo "Test: checkpoint-timer regression (issue #159)"
+echo "============================================================"
+echo "  Watermark dir: $WM_DIR"
+echo "  Transcript:    $TRANSCRIPT_PATH"
+echo ""
+
+# ---------------------------------------------------------------------------
+# Defect 1 — timer spawns even though transcript does not exist yet.
+# session-start.sh backgrounds the timer; capture.js session-start will fail to
+# reach MCP but must not block the spawn. The timer must remain alive after its
+# first tick while transcript creation is still within the startup grace period.
+# ---------------------------------------------------------------------------
+echo "--- Defect 1: spawn race (transcript absent at SessionStart) ---"
+log "Transcript absent before hook"
+[ ! -f "$TRANSCRIPT_PATH" ] && pass || fail "transcript unexpectedly exists"
+
+# Spawn the timer directly the way the fixed session-start.sh does. A one-second
+# interval guarantees the missing-transcript branch runs before the assertion.
+MEKO_CHECKPOINT_INTERVAL=1 MEKO_TIMER_MAX_AGE=999 MEKO_TIMER_IDLE_EXIT=999 \
+  MEKO_TIMER_STARTUP_GRACE=10 \
+  nohup node "$TIMER_JS" "$TRANSCRIPT_PATH" </dev/null >/dev/null 2>&1 &
+TIMER_PID=$!
+SPAWNED_PIDS+=("$TIMER_PID")
+sleep 1.5
+
+log "Timer survives first tick with missing transcript"
+if kill -0 "$TIMER_PID" 2>/dev/null; then pass "pid $TIMER_PID"; else fail "timer did not stay up"; fi
+
+log "Timer wrote its pid file"
+[ -f "$PID_FILE" ] && pass || fail "no pid file at $PID_FILE"
+
+kill "$TIMER_PID" 2>/dev/null || true
+wait_gone "$TIMER_PID" || true
+rm -f "$PID_FILE"
+
+# ---------------------------------------------------------------------------
+# Defect 3a — max-age self-exit. Transcript exists and is fresh, but max-age is
+# tiny, so the first tick must self-exit and remove its pid file.
+# ---------------------------------------------------------------------------
+echo ""
+echo "--- Defect 3a: max-age self-exit backstop ---"
+printf '{"type":"user","uuid":"u1","message":{"content":"hi"}}\n' > "$TRANSCRIPT_PATH"
+
+MEKO_CHECKPOINT_INTERVAL=1 MEKO_TIMER_MAX_AGE=1 MEKO_TIMER_IDLE_EXIT=999 \
+  nohup node "$TIMER_JS" "$TRANSCRIPT_PATH" </dev/null >/dev/null 2>&1 &
+TIMER_PID=$!
+SPAWNED_PIDS+=("$TIMER_PID")
+
+log "Timer self-exits after max-age"
+if wait_gone "$TIMER_PID" 60; then pass; else fail "still running after max-age"; fi
+
+log "Pid file removed on self-exit"
+[ ! -f "$PID_FILE" ] && pass || fail "stale pid file remains"
+
+# ---------------------------------------------------------------------------
+# Defect 3b — idle self-exit. Make the transcript look old (mtime in the past)
+# so the idle backstop trips on the first tick.
+# ---------------------------------------------------------------------------
+echo ""
+echo "--- Defect 3b: idle self-exit backstop ---"
+printf '{"type":"user","uuid":"u1","message":{"content":"hi"}}\n' > "$TRANSCRIPT_PATH"
+touch -t 202001010000 "$TRANSCRIPT_PATH"   # far in the past
+
+MEKO_CHECKPOINT_INTERVAL=1 MEKO_TIMER_MAX_AGE=999 MEKO_TIMER_IDLE_EXIT=1 \
+  nohup node "$TIMER_JS" "$TRANSCRIPT_PATH" </dev/null >/dev/null 2>&1 &
+TIMER_PID=$!
+SPAWNED_PIDS+=("$TIMER_PID")
+
+log "Timer self-exits on idle transcript"
+if wait_gone "$TIMER_PID" 60; then pass; else fail "still running with idle transcript"; fi
+
+# ---------------------------------------------------------------------------
+# Defect 3c — session-end.sh kills by transcript path when the pid file is gone.
+# ---------------------------------------------------------------------------
+echo ""
+echo "--- Defect 3c: session-end path-based kill (no pid file) ---"
+printf '{"type":"user","uuid":"u1","message":{"content":"hi"}}\n' > "$TRANSCRIPT_PATH"
+
+# Long-lived timer; then delete its pid file to simulate the orphan condition.
+MEKO_CHECKPOINT_INTERVAL=999 MEKO_TIMER_MAX_AGE=999 MEKO_TIMER_IDLE_EXIT=999 \
+  nohup node "$TIMER_JS" "$TRANSCRIPT_PATH" </dev/null >/dev/null 2>&1 &
+TIMER_PID=$!
+SPAWNED_PIDS+=("$TIMER_PID")
+sleep 0.5
+rm -f "$PID_FILE"   # pid file vanished out of band -> classic orphan setup
+
+log "Orphan timer running with no pid file"
+if kill -0 "$TIMER_PID" 2>/dev/null && [ ! -f "$PID_FILE" ]; then pass "pid $TIMER_PID"; else fail "precondition not met"; fi
+
+# session-end.sh must find it by transcript path and kill it.
+printf '{"transcript_path":"%s"}' "$TRANSCRIPT_PATH" | bash "$SESSION_END" >/dev/null 2>&1 || true
+
+log "session-end.sh killed the orphan by transcript path"
+if wait_gone "$TIMER_PID" 30; then pass; else fail "orphan survived session-end"; fi
+
+# ---------------------------------------------------------------------------
+echo ""
+echo "============================================================"
+TOTAL=$((PASS + FAIL))
+echo "  Total: $TOTAL  |  Passed: $PASS  |  Failed: $FAIL"
+echo "============================================================"
+[ "$FAIL" -gt 0 ] && { echo "  RESULT: FAILED"; exit 1; } || { echo "  RESULT: ALL PASSED"; exit 0; }

package/assets/scripts/meko-statusline.sh

@@ -0,0 +1,119 @@
+#!/usr/bin/env bash
+# meko-statusline.sh — Claude Code statusline contribution showing the active Meko datapack pin.
+#
+# Composable: if --inner-cmd is provided (or MEKO_INNER_STATUSLINE env var), runs it first and
+# appends our suffix. So a user with an existing statusLine doesn't lose it.
+#
+# Usage in ~/.claude/settings.json (after installer wires it):
+#   { "statusLine": { "type": "command", "command": "$HOME/.claude/meko-statusline.sh --inner-cmd <existing-cmd>" } }
+#
+# Or, if you maintain the inner command separately, set MEKO_INNER_STATUSLINE=<cmd> in env.
+#
+# Outputs nothing (empty string) when no pin is set, so the indicator is invisible until you pin.
+# The output goes on stdout — Claude Code displays it as-is, supporting ANSI color codes if you
+# wrap the suffix.
+#
+# Reads JSON from stdin (Claude Code passes session metadata) and forwards it verbatim to the inner
+# command. The inner command's stdout is printed first, then our suffix.
+
+set -u
+
+INNER_CMD=""
+if [[ "${1:-}" == "--inner-cmd" && -n "${2:-}" ]]; then
+  INNER_CMD="$2"
+elif [[ -n "${MEKO_INNER_STATUSLINE:-}" ]]; then
+  INNER_CMD="$MEKO_INNER_STATUSLINE"
+fi
+
+# Buffer stdin once so we can pipe the same JSON to both the inner command and our derivation.
+STDIN_PAYLOAD=""
+if [[ -p /dev/stdin || ! -t 0 ]]; then
+  STDIN_PAYLOAD="$(cat)"
+fi
+
+# --- Inner command first (preserves any pre-existing statusline content) ---
+
+if [[ -n "$INNER_CMD" ]]; then
+  if [[ -n "$STDIN_PAYLOAD" ]]; then
+    INNER_OUT="$(printf '%s' "$STDIN_PAYLOAD" | eval "$INNER_CMD" 2>/dev/null || true)"
+  else
+    INNER_OUT="$(eval "$INNER_CMD" 2>/dev/null || true)"
+  fi
+  # Strip a single trailing newline so our suffix appears on the same line.
+  INNER_OUT="${INNER_OUT%$'\n'}"
+  printf '%s' "$INNER_OUT"
+fi
+
+# --- Derive agent_id from cwd ---
+#
+# Mirrors deriveAgentId() in skills/hooks-handlers/lib/capture.js:51-65:
+#   - basename of cwd, lowercased
+#   - non-[a-z0-9-]+ → '-'
+#   - trim leading/trailing '-'
+#   - max 64 chars
+#   - prefix with 'claude_code:'
+#
+# Then mirrors datapackPinSlug() in capture.js:341-348:
+#   - non-[A-Za-z0-9._-]+ → '_'
+#   - trim leading/trailing '_'
+#
+# Prefer cwd from the JSON stdin payload (Claude Code's session metadata format), falling back
+# to PWD if stdin was empty / not piped.
+
+CWD="$PWD"
+if [[ -n "$STDIN_PAYLOAD" ]]; then
+  # Best-effort extraction without requiring jq. Look for "cwd":"…" first; fall back to "workspace":{"current_dir":"…"}.
+  # Isolate the exact key/value pair with grep -oE before extracting so a greedy `.*` can't grab a
+  # different key that merely ends in `cwd`/`current_dir` earlier on the same line.
+  EXTRACTED="$(printf '%s' "$STDIN_PAYLOAD" | grep -oE '"cwd"[[:space:]]*:[[:space:]]*"[^"]+"' | sed -E 's/.*"([^"]+)"$/\1/' | head -n 1)"
+  if [[ -z "$EXTRACTED" ]]; then
+    EXTRACTED="$(printf '%s' "$STDIN_PAYLOAD" | grep -oE '"current_dir"[[:space:]]*:[[:space:]]*"[^"]+"' | sed -E 's/.*"([^"]+)"$/\1/' | head -n 1)"
+  fi
+  if [[ -n "$EXTRACTED" ]]; then
+    CWD="$EXTRACTED"
+  fi
+fi
+
+# MEKO_AGENT_ID overrides the cwd-derived id, matching resolveSessionAgentId() in
+# capture.js (the env override wins verbatim when non-empty).
+if [[ -n "${MEKO_AGENT_ID:-}" ]]; then
+  AGENT_ID="$MEKO_AGENT_ID"
+else
+  BASENAME="$(basename "$CWD")"
+  PROJECT_SLUG="$(printf '%s' "$BASENAME" | tr '[:upper:]' '[:lower:]' | sed -E 's/[^a-z0-9-]+/-/g; s/^-+|-+$//g')"
+  PROJECT_SLUG="${PROJECT_SLUG:0:64}"
+
+  if [[ -z "$PROJECT_SLUG" || "$PROJECT_SLUG" == "-" ]]; then
+    AGENT_ID="claude_code"
+  else
+    AGENT_ID="claude_code:$PROJECT_SLUG"
+  fi
+fi
+
+PIN_SLUG="$(printf '%s' "$AGENT_ID" | sed -E 's/[^A-Za-z0-9._-]+/_/g; s/^_+|_+$//g')"
+# Match datapackPinSlug() in capture.js: an empty slug falls back to the common bucket
+# (meko_agent), so both components look for the same pin file.
+if [[ -z "$PIN_SLUG" ]]; then
+  PIN_SLUG="meko_agent"
+fi
+PIN_FILE="${MEKO_WATERMARK_DIR:-$HOME/.claude/meko-capture}/pin-${PIN_SLUG}.json"
+
+# --- Read the pin file and append the suffix if a valid pin is present ---
+
+if [[ -f "$PIN_FILE" ]]; then
+  # grep -oE isolates the exact "datapack_name":"…" pair before extracting, so a
+  # greedy `.*` can't grab a different key that merely ends in datapack_name.
+  PIN_NAME="$(grep -oE '"datapack_name"[[:space:]]*:[[:space:]]*"[^"]+"' "$PIN_FILE" | sed -E 's/.*"([^"]+)"$/\1/' | head -n 1)"
+  if [[ -n "$PIN_NAME" ]]; then
+    SUFFIX="Meko: $PIN_NAME"
+    # Add a separator only if the inner command produced output.
+    if [[ -n "${INNER_OUT:-}" ]]; then
+      printf ' \xe2\x80\xa2 %s' "$SUFFIX"
+    else
+      printf '%s' "$SUFFIX"
+    fi
+  fi
+fi
+
+# Always finish with a newline so subsequent shell renders cleanly.
+printf '\n'

package/assets/scripts/package-desktop-skill.sh

@@ -1,36 +1,70 @@
 #!/usr/bin/env bash
-# Package meko-mcp-tools-desktop as a .skill file for Claude Desktop distribution.
+# Package the Claude Desktop skills as importable .skill files.
 # Usage: bash scripts/package-desktop-skill.sh
-# Output: meko-mcp-tools-desktop.skill (ZIP archive)
+# Outputs: meko-mcp-tools-desktop.skill and meko-select-datapack-desktop.skill
 
 set -euo pipefail
 
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-SKILLS_ROOT="$SCRIPT_DIR/../skills"
-SKILL_NAME="meko-mcp-tools-desktop"
-OUTPUT="$SCRIPT_DIR/../$SKILL_NAME.skill"
-
-if [ ! -d "$SKILLS_ROOT/$SKILL_NAME" ]; then
-    echo "Error: Skill directory not found at $SKILLS_ROOT/$SKILL_NAME" >&2
-    exit 1
-fi
-
-if [ ! -f "$SKILLS_ROOT/$SKILL_NAME/SKILL.md" ]; then
-    echo "Error: SKILL.md not found in $SKILLS_ROOT/$SKILL_NAME/" >&2
-    exit 1
-fi
-
-# Remove previous build if it exists
-rm -f "$OUTPUT"
-
-# Package skill + references (exclude OS artifacts and desktop README)
-cd "$SKILLS_ROOT"
-zip -r "$OUTPUT" \
-    "$SKILL_NAME/SKILL.md" \
-    "$SKILL_NAME/references/" \
-    -x "*.DS_Store" "*__pycache__*"
-
-echo "Created $OUTPUT ($(du -h "$OUTPUT" | cut -f1))"
-echo ""
-echo "Contents:"
-unzip -l "$OUTPUT" | grep -E "^\s+[0-9]" | grep -v "files$"
+SKILLS_ROOT="${MEKO_DESKTOP_SKILLS_ROOT:-$SCRIPT_DIR/../skills}"
+SKILL_NAMES=("meko-mcp-tools-desktop" "meko-select-datapack-desktop")
+XML_TAG_PATTERN='</?[[:alpha:]_:][[:alnum:]_.:-]*([[:blank:]][^<>]*)?[[:blank:]]*/?>'
+
+for SKILL_NAME in "${SKILL_NAMES[@]}"; do
+    if [ ! -d "$SKILLS_ROOT/$SKILL_NAME" ]; then
+        echo "Error: Skill directory not found at $SKILLS_ROOT/$SKILL_NAME" >&2
+        exit 1
+    fi
+
+    if [ ! -f "$SKILLS_ROOT/$SKILL_NAME/SKILL.md" ]; then
+        echo "Error: SKILL.md not found in $SKILLS_ROOT/$SKILL_NAME/" >&2
+        exit 1
+    fi
+
+    if ! grep -q '^description:[[:space:]]*' "$SKILLS_ROOT/$SKILL_NAME/SKILL.md"; then
+        echo "Error: SKILL.md description is missing: $SKILL_NAME" >&2
+        exit 1
+    fi
+
+    DESCRIPTION="$(awk '
+        /^description:[[:space:]]*/ {
+            in_description = 1
+            value = $0
+            sub(/^description:[[:space:]]*/, "", value)
+            if (value !~ /^[>|][+-]?$/) printf "%s ", value
+            next
+        }
+        in_description && /^[^[:space:]]/ { exit }
+        in_description {
+            sub(/^[[:space:]]+/, "")
+            printf "%s ", $0
+        }
+    ' "$SKILLS_ROOT/$SKILL_NAME/SKILL.md")"
+
+    if [[ -z "${DESCRIPTION//[[:space:]]/}" ]]; then
+        echo "Error: SKILL.md description is empty: $SKILL_NAME" >&2
+        exit 1
+    fi
+
+    if printf '%s\n' "$DESCRIPTION" | grep -Eq "$XML_TAG_PATTERN"; then
+        echo "Error: SKILL.md description cannot contain XML-like tags: $SKILL_NAME" >&2
+        exit 1
+    fi
+done
+
+for SKILL_NAME in "${SKILL_NAMES[@]}"; do
+    OUTPUT="$SCRIPT_DIR/../$SKILL_NAME.skill"
+    rm -f "$OUTPUT"
+
+    # Package skill + references (exclude OS artifacts and desktop README)
+    cd "$SKILLS_ROOT"
+    zip -r "$OUTPUT" \
+        "$SKILL_NAME/SKILL.md" \
+        "$SKILL_NAME/references/" \
+        -x "*.DS_Store" "*__pycache__*"
+
+    echo "Created $OUTPUT ($(du -h "$OUTPUT" | cut -f1))"
+    echo ""
+    echo "Contents:"
+    unzip -l "$OUTPUT" | grep -E "^\s+[0-9]" | grep -v "files$"
+done