codymaster 5.2.0 → 7.0.1

package/scripts/build-skills-lock.mjs

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+/**
+ * Build/refresh skills-lock.json with sha256 + version for every skill.
+ *
+ * Usage:
+ *   node scripts/build-skills-lock.mjs           → rewrite skills-lock.json
+ *   node scripts/build-skills-lock.mjs --check   → exit 1 on drift, no write
+ */
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ROOT = path.resolve(__dirname, '..');
+const SKILLS = path.join(ROOT, 'skills');
+const LOCK = path.join(ROOT, 'skills-lock.json');
+
+const args = new Set(process.argv.slice(2));
+const checkOnly = args.has('--check');
+
+function sha256(file) {
+  return crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+}
+
+function parseFrontmatter(text) {
+  const m = text.match(/^---\n([\s\S]*?)\n---/);
+  if (!m) return {};
+  const out = {};
+  const v = m[1].match(/^version:\s*['"]?([\w.\-+]+)['"]?\s*$/m);
+  if (v) out.version = v[1];
+  const d = m[1].match(/^deprecated:\s*(true|false)\s*$/m);
+  if (d) out.deprecated = d[1] === 'true';
+  return out;
+}
+
+function buildLock() {
+  const skills = {};
+  if (fs.existsSync(SKILLS)) {
+    for (const name of fs.readdirSync(SKILLS).sort()) {
+      if (!name.startsWith('cm-')) continue;
+      const skillFile = path.join(SKILLS, name, 'SKILL.md');
+      if (!fs.existsSync(skillFile)) continue;
+      const text = fs.readFileSync(skillFile, 'utf8');
+      const fm = parseFrontmatter(text);
+      skills[name] = {
+        sha256: sha256(skillFile),
+        ...(fm.version ? { version: fm.version } : {}),
+        ...(fm.deprecated ? { deprecated: true } : {}),
+      };
+    }
+  }
+  return {
+    version: 2,
+    generated_at: new Date().toISOString(),
+    skills,
+  };
+}
+
+const next = buildLock();
+
+if (checkOnly) {
+  if (!fs.existsSync(LOCK)) {
+    console.error('✗ skills-lock.json missing');
+    process.exit(1);
+  }
+  const prev = JSON.parse(fs.readFileSync(LOCK, 'utf8'));
+  const drift = [];
+  for (const [name, entry] of Object.entries(next.skills)) {
+    const before = prev.skills?.[name];
+    if (!before) drift.push(`+ ${name} (new)`);
+    else if (before.sha256 !== entry.sha256) drift.push(`Δ ${name} (hash drift)`);
+  }
+  for (const name of Object.keys(prev.skills ?? {})) {
+    if (!next.skills[name]) drift.push(`- ${name} (removed)`);
+  }
+  if (drift.length) {
+    console.error('✗ skills-lock drift:');
+    for (const line of drift) console.error('  ' + line);
+    console.error('Run `node scripts/build-skills-lock.mjs` to refresh.');
+    process.exit(1);
+  }
+  console.log(`✓ skills-lock OK (${Object.keys(next.skills).length} skills)`);
+  process.exit(0);
+}
+
+fs.writeFileSync(LOCK, JSON.stringify(next, null, 2) + '\n', 'utf8');
+console.log(`✓ wrote skills-lock.json (${Object.keys(next.skills).length} skills)`);

package/scripts/build-skills.mjs

@@ -1,46 +1,157 @@
 #!/usr/bin/env node
 /**
- * Generate SKILL.md from SKILL.md.tmpl + meta.json when present.
- * Usage: node scripts/build-skills.mjs [--check]
+ * Build / sync skills.
+ *
+ * Modes:
+ *   1. Template render — reads skills/<name>/SKILL.md.tmpl + meta.json,
+ *      writes SKILL.md. Always runs.
+ *   2. Multi-platform sync — when --platforms is passed (or --all-platforms),
+ *      mirrors ALL cm-* skill folders + _shared/ into per-platform install dirs.
+ *
+ * Usage:
+ *   node scripts/build-skills.mjs                                 # template only
+ *   node scripts/build-skills.mjs --check                         # template + (when --platforms) drift check
+ *   node scripts/build-skills.mjs --platforms cursor,codex,opencode
+ *   node scripts/build-skills.mjs --all-platforms
  */
 import fs from 'fs';
 import path from 'path';
+import crypto from 'crypto';
 import { fileURLToPath } from 'url';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const skillsRoot = path.join(__dirname, '..', 'skills');
-const check = process.argv.includes('--check');
+const repoRoot = path.join(__dirname, '..');
+const skillsRoot = path.join(repoRoot, 'skills');
+const args = process.argv.slice(2);
+const check = args.includes('--check');
+
+function getFlag(name) {
+  const i = args.indexOf(`--${name}`);
+  if (i === -1) return null;
+  return args[i + 1] ?? '';
+}
+
+const platformsArg = getFlag('platforms');
+const allPlatforms = args.includes('--all-platforms');
+
+// All 14 supported platforms
+const PLATFORM_DIRS = {
+  'claude-code': path.join(repoRoot, '.claude', 'skills'),
+  'claude-desktop': path.join(repoRoot, '.claude-desktop', 'skills'),
+  cursor: path.join(repoRoot, '.cursor-plugin', 'skills'),
+  windsurf: path.join(repoRoot, '.windsurf', 'skills'),
+  antigravity: path.join(repoRoot, '.gemini', 'skills'),
+  codex: path.join(repoRoot, '.codex', 'skills'),
+  opencode: path.join(repoRoot, '.opencode', 'skills'),
+  cline: path.join(repoRoot, '.cline', 'skills'),
+  kiro: path.join(repoRoot, '.kiro', 'skills'),
+  copilot: path.join(repoRoot, '.copilot', 'skills'),
+  aider: path.join(repoRoot, '.aider', 'skills'),
+  continue: path.join(repoRoot, '.continue', 'skills'),
+  'amazon-q': path.join(repoRoot, '.amazonq', 'skills'),
+  amp: path.join(repoRoot, '.amp', 'skills'),
+};
 
 function render(tmpl, vars) {
   return tmpl.replace(/\{\{(\w+)\}\}/g, (_, k) => (vars[k] != null ? String(vars[k]) : `{{${k}}}`));
 }
 
-let tmplCount = 0;
-if (!fs.existsSync(skillsRoot)) process.exit(0);
-
-for (const dir of fs.readdirSync(skillsRoot, { withFileTypes: true })) {
-  if (!dir.isDirectory()) continue;
-  const folder = path.join(skillsRoot, dir.name);
-  const tmplPath = path.join(folder, 'SKILL.md.tmpl');
-  const metaPath = path.join(folder, 'meta.json');
-  const outPath = path.join(folder, 'SKILL.md');
-  if (!fs.existsSync(tmplPath)) continue;
-
-  tmplCount++;
-  const tmpl = fs.readFileSync(tmplPath, 'utf8');
-  let meta = {};
-  if (fs.existsSync(metaPath)) {
-    meta = JSON.parse(fs.readFileSync(metaPath, 'utf8'));
+function sha256(buf) {
+  return crypto.createHash('sha256').update(buf).digest('hex');
+}
+
+function ensureDir(p) {
+  fs.mkdirSync(p, { recursive: true });
+}
+
+function copyFileIdempotent(src, dst) {
+  const srcBuf = fs.readFileSync(src);
+  if (fs.existsSync(dst)) {
+    const dstBuf = fs.readFileSync(dst);
+    if (sha256(srcBuf) === sha256(dstBuf)) return 'skipped';
   }
-  const out = render(tmpl, meta);
-  if (check) {
-    const cur = fs.existsSync(outPath) ? fs.readFileSync(outPath, 'utf8') : '';
-    if (cur !== out) {
-      console.error(`check failed: ${outPath} out of date (run npm run build:skills)`);
-      process.exit(2);
+  if (check) return 'drift';
+  ensureDir(path.dirname(dst));
+  fs.writeFileSync(dst, srcBuf);
+  return 'synced';
+}
+
+function copyDirShallow(srcDir, dstDir) {
+  const result = { synced: 0, skipped: 0, drift: 0 };
+  if (!fs.existsSync(srcDir)) return result;
+  ensureDir(dstDir);
+
+  const skillFile = path.join(srcDir, 'SKILL.md');
+  if (fs.existsSync(skillFile)) {
+    result[copyFileIdempotent(skillFile, path.join(dstDir, 'SKILL.md'))]++;
+  }
+
+  const refDir = path.join(srcDir, 'references');
+  if (fs.existsSync(refDir) && fs.statSync(refDir).isDirectory()) {
+    for (const entry of fs.readdirSync(refDir)) {
+      const s = path.join(refDir, entry);
+      if (fs.statSync(s).isFile()) {
+        result[copyFileIdempotent(s, path.join(dstDir, 'references', entry))]++;
+      }
+    }
+  }
+  return result;
+}
+
+// Copy _shared/ directory recursively
+function copySharedHelpers(srcRoot, dstRoot) {
+  const sharedSrc = path.join(srcRoot, '_shared');
+  const sharedDst = path.join(dstRoot, '_shared');
+  if (!fs.existsSync(sharedSrc)) return { synced: 0, skipped: 0, drift: 0 };
+  
+  const result = { synced: 0, skipped: 0, drift: 0 };
+  ensureDir(sharedDst);
+  
+  for (const entry of fs.readdirSync(sharedSrc)) {
+    const srcFile = path.join(sharedSrc, entry);
+    const dstFile = path.join(sharedDst, entry);
+    if (fs.statSync(srcFile).isFile()) {
+      result[copyFileIdempotent(srcFile, dstFile)]++;
+    }
+  }
+  return result;
+}
+
+// Get ALL cm-* skills from skills/ directory
+function getAllCmSkills() {
+  if (!fs.existsSync(skillsRoot)) return [];
+  return fs.readdirSync(skillsRoot, { withFileTypes: true })
+    .filter(d => d.isDirectory() && d.name.startsWith('cm-'))
+    .map(d => d.name);
+}
+
+// --- Mode 1: template render ---
+let tmplCount = 0;
+if (fs.existsSync(skillsRoot)) {
+  for (const dir of fs.readdirSync(skillsRoot, { withFileTypes: true })) {
+    if (!dir.isDirectory()) continue;
+    const folder = path.join(skillsRoot, dir.name);
+    const tmplPath = path.join(folder, 'SKILL.md.tmpl');
+    const metaPath = path.join(folder, 'meta.json');
+    const outPath = path.join(folder, 'SKILL.md');
+    if (!fs.existsSync(tmplPath)) continue;
+
+    tmplCount++;
+    const tmpl = fs.readFileSync(tmplPath, 'utf8');
+    let meta = {};
+    if (fs.existsSync(metaPath)) {
+      meta = JSON.parse(fs.readFileSync(metaPath, 'utf8'));
+    }
+    const out = render(tmpl, meta);
+    if (check) {
+      const cur = fs.existsSync(outPath) ? fs.readFileSync(outPath, 'utf8') : '';
+      if (cur !== out) {
+        console.error(`check failed: ${outPath} out of date (run npm run build:skills)`);
+        process.exit(2);
+      }
+    } else {
+      fs.writeFileSync(outPath, out, 'utf8');
     }
-  } else {
-    fs.writeFileSync(outPath, out, 'utf8');
   }
 }
 
@@ -49,3 +160,51 @@ if (tmplCount === 0) {
 } else {
   console.log(check ? `build-skills: --check OK (${tmplCount})` : `build-skills: wrote ${tmplCount} skill(s)`);
 }
+
+// --- Mode 2: multi-platform sync ---
+let platforms = [];
+if (allPlatforms) platforms = Object.keys(PLATFORM_DIRS);
+else if (platformsArg) {
+  platforms = platformsArg.split(',').map(s => s.trim()).filter(Boolean);
+}
+
+if (platforms.length > 0) {
+  // Get ALL cm-* skills (not just top 35)
+  const list = getAllCmSkills();
+  console.log(`build-skills: found ${list.length} cm-* skills to sync`);
+
+  for (const platform of platforms) {
+    const dst = PLATFORM_DIRS[platform];
+    if (!dst) {
+      console.error(`build-skills: unknown platform '${platform}' (valid: ${Object.keys(PLATFORM_DIRS).join(',')})`);
+      process.exit(2);
+    }
+    
+    let synced = 0, skipped = 0, drift = 0, missing = 0;
+    
+    // Sync _shared/ helpers
+    const sharedResult = copySharedHelpers(skillsRoot, dst);
+    synced += sharedResult.synced;
+    skipped += sharedResult.skipped;
+    drift += sharedResult.drift;
+    
+    // Sync ALL cm-* skills
+    for (const name of list) {
+      const srcDir = path.join(skillsRoot, name);
+      if (!fs.existsSync(srcDir)) {
+        missing++;
+        console.warn(`  ! ${platform}: skill '${name}' not found in skills/`);
+        continue;
+      }
+      const r = copyDirShallow(srcDir, path.join(dst, name));
+      synced += r.synced; skipped += r.skipped; drift += r.drift;
+    }
+    
+    if (check && drift > 0) {
+      console.error(`build-skills: --check FAILED for ${platform} (drift=${drift})`);
+      process.exit(2);
+    }
+    const tag = check ? 'check' : 'sync';
+    console.log(`build-skills[${platform}] ${tag}: synced=${synced} skipped=${skipped} drift=${drift} missing=${missing} total=${list.length + 1}`);
+  }
+}

package/scripts/compress-skill.mjs

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+/**
+ * Migrate a skill to v2 compressed format.
+ *
+ *   - Adds frontmatter: `token_budget: <N>`, `compressed: true`, `deprecated: false`
+ *   - Inserts `## TL;DR` block after the H1 if not present
+ *   - Preserves the rest of the body verbatim
+ *
+ * Usage:
+ *   node scripts/compress-skill.mjs <skill-name> <token_budget> "<tldr-line-1>" "<tldr-line-2>" ...
+ *
+ * Idempotent: skips skills already marked `compressed: true`.
+ */
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const [, , name, budgetArg, ...tldrLines] = process.argv;
+if (!name || !budgetArg || tldrLines.length === 0) {
+  console.error('Usage: compress-skill.mjs <skill-name> <token_budget> "<tldr-1>" ["<tldr-2>" ...]');
+  process.exit(1);
+}
+const budget = parseInt(budgetArg, 10);
+if (Number.isNaN(budget) || budget < 100 || budget > 6000) {
+  console.error(`token_budget must be int 100..6000, got: ${budgetArg}`);
+  process.exit(1);
+}
+
+const file = path.join(__dirname, '..', 'skills', name, 'SKILL.md');
+if (!fs.existsSync(file)) {
+  console.error(`✗ ${name}: SKILL.md not found`);
+  process.exit(1);
+}
+
+const original = fs.readFileSync(file, 'utf8');
+if (/^compressed:\s*true/m.test(original)) {
+  console.log(`• ${name}: already compressed, skipping`);
+  process.exit(0);
+}
+
+const fmMatch = original.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+if (!fmMatch) {
+  console.error(`✗ ${name}: missing YAML frontmatter`);
+  process.exit(1);
+}
+let fmText = fmMatch[1];
+const body = fmMatch[2];
+
+// Append fields if missing.
+if (!/^token_budget:/m.test(fmText)) fmText += `\ntoken_budget: ${budget}`;
+if (!/^compressed:/m.test(fmText)) fmText += `\ncompressed: true`;
+if (!/^deprecated:/m.test(fmText)) fmText += `\ndeprecated: false`;
+
+// Insert ## TL;DR after the H1 if absent.
+let newBody = body;
+if (!/^##\s+TL;DR\b/m.test(body)) {
+  const h1 = body.match(/^(#\s+[^\n]+\n)/m);
+  if (!h1) {
+    console.error(`✗ ${name}: missing H1`);
+    process.exit(1);
+  }
+  const tldrBlock =
+    `\n## TL;DR\n` +
+    tldrLines.map((l) => `- ${l}`).join('\n') +
+    `\n`;
+  newBody = body.replace(h1[0], h1[0] + tldrBlock);
+}
+
+const out = `---\n${fmText}\n---\n${newBody}`;
+fs.writeFileSync(file, out, 'utf8');
+console.log(`✓ ${name}: compressed (budget=${budget})`);

package/scripts/deprecate-skill.mjs

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+/**
+ * Deprecate a skill: archives original SKILL.md to SKILL.archive.md
+ * and replaces SKILL.md with a small redirect stub.
+ *
+ * Usage:
+ *   node scripts/deprecate-skill.mjs <skill-name> <merged-into> [reason]
+ *
+ * Idempotent: skips if SKILL.md already has `deprecated: true`.
+ */
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const [, , name, mergedInto, ...reasonParts] = process.argv;
+if (!name || !mergedInto) {
+  console.error('Usage: deprecate-skill.mjs <skill-name> <merged-into> [reason]');
+  process.exit(1);
+}
+const reason = reasonParts.join(' ') || `consolidated into ${mergedInto}`;
+
+const dir = path.join(__dirname, '..', 'skills', name);
+const file = path.join(dir, 'SKILL.md');
+const archive = path.join(dir, 'SKILL.archive.md');
+
+if (!fs.existsSync(file)) {
+  console.error(`✗ ${name}: SKILL.md not found`);
+  process.exit(1);
+}
+
+const original = fs.readFileSync(file, 'utf8');
+if (/^deprecated:\s*true/m.test(original)) {
+  console.log(`• ${name}: already deprecated, skipping`);
+  process.exit(0);
+}
+
+if (!fs.existsSync(archive)) {
+  fs.writeFileSync(archive, original, 'utf8');
+}
+
+const stub = `---
+name: ${name}
+description: "[Deprecated] ${reason}. Use \`${mergedInto}\` instead."
+deprecated: true
+merged_into: ${mergedInto}
+---
+
+# ${name} — Deprecated
+
+> ⚠️ This skill is deprecated as of CodyMaster v6.0.0 and will be removed in v6.1.0.
+>
+> **Use \`${mergedInto}\` instead.** ${reason}.
+>
+> See [docs/migration-v2.md](../../docs/migration-v2.md) for the full mapping.
+
+The original content is preserved at [SKILL.archive.md](SKILL.archive.md) for reference.
+
+## Migration
+
+\`\`\`bash
+# Old:           cm <use this skill>
+# New (v6.0+):   cm ${mergedInto.replace(/^cm-/, '')} <equivalent action>
+\`\`\`
+
+If you depend on a capability that didn't carry over, please file an issue:
+https://github.com/tody-agent/codymaster/issues
+`;
+
+fs.writeFileSync(file, stub, 'utf8');
+console.log(`✓ ${name} → deprecated, redirects to ${mergedInto}`);

package/scripts/install.sh

@@ -0,0 +1,170 @@
+#!/bin/bash
+# CodyMaster CLI Installer
+# Usage: curl -fsSL https://raw.githubusercontent.com/todyle/codymaster/main/scripts/install.sh | bash
+#
+# Detects platform, checks prerequisites, installs globally via npm.
+
+set -e
+
+CM_VERSION="${CM_VERSION:-latest}"
+PACKAGE_NAME="codymaster"
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+BOLD='\033[1m'
+RESET='\033[0m'
+
+info()  { echo -e "${BLUE}  ℹ ${RESET}$1"; }
+ok()    { echo -e "${GREEN}  ✅ ${RESET}$1"; }
+warn()  { echo -e "${YELLOW}  ⚠️  ${RESET}$1"; }
+err()   { echo -e "${RED}  ❌ ${RESET}$1"; }
+
+echo ""
+echo -e "${BOLD}  🐹 CodyMaster Installer${RESET}"
+echo -e "  The Hamster-Powered AI Agent Framework"
+echo ""
+
+# ─── Detect Platform ──────────────────────────────────────────────
+detect_platform() {
+  local os arch
+
+  case "$(uname -s)" in
+    Darwin*)    os="macos" ;;
+    Linux*)     os="linux" ;;
+    MINGW*|MSYS*|CYGWIN*)  os="windows" ;;
+    *)          os="unknown" ;;
+  esac
+
+  case "$(uname -m)" in
+    x86_64|amd64)   arch="x64" ;;
+    arm64|aarch64)   arch="arm64" ;;
+    *)               arch="$(uname -m)" ;;
+  esac
+
+  echo "${os}-${arch}"
+}
+
+PLATFORM=$(detect_platform)
+info "Platform: ${PLATFORM}"
+
+# ─── Check Node.js ────────────────────────────────────────────────
+check_node() {
+  if command -v node &>/dev/null; then
+    local node_version
+    node_version=$(node --version 2>/dev/null | sed 's/v//')
+    local major
+    major=$(echo "$node_version" | cut -d. -f1)
+
+    if [ "$major" -ge 18 ]; then
+      ok "Node.js v${node_version} found"
+      return 0
+    else
+      err "Node.js v${node_version} found but v18+ required"
+      return 1
+    fi
+  else
+    err "Node.js not found"
+    return 1
+  fi
+}
+
+# ─── Check npm ────────────────────────────────────────────────────
+check_npm() {
+  if command -v npm &>/dev/null; then
+    local npm_version
+    npm_version=$(npm --version 2>/dev/null)
+    ok "npm v${npm_version} found"
+    return 0
+  else
+    err "npm not found"
+    return 1
+  fi
+}
+
+# ─── Install Node.js if missing ───────────────────────────────────
+install_node() {
+  info "Installing Node.js via nvm..."
+
+  if command -v nvm &>/dev/null; then
+    nvm install --lts
+    nvm use --lts
+  elif [ -f "$HOME/.nvm/nvm.sh" ]; then
+    # shellcheck source=/dev/null
+    source "$HOME/.nvm/nvm.sh"
+    nvm install --lts
+    nvm use --lts
+  else
+    # Install nvm
+    info "Installing nvm..."
+    curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash
+
+    export NVM_DIR="$HOME/.nvm"
+    # shellcheck source=/dev/null
+    [ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh"
+    nvm install --lts
+    nvm use --lts
+  fi
+
+  if check_node; then
+    ok "Node.js installed successfully"
+  else
+    err "Node.js installation failed. Please install manually: https://nodejs.org"
+    exit 1
+  fi
+}
+
+# ─── Main Install Flow ───────────────────────────────────────────
+main() {
+  # Check/install Node.js
+  if ! check_node; then
+    install_node
+  fi
+
+  # Check npm
+  if ! check_npm; then
+    err "npm is required but not found. Please install Node.js from https://nodejs.org"
+    exit 1
+  fi
+
+  # Install codymaster
+  echo ""
+  info "Installing codymaster..."
+
+  if [ "$CM_VERSION" = "latest" ]; then
+    npm install -g "$PACKAGE_NAME@latest"
+  else
+    npm install -g "$PACKAGE_NAME@${CM_VERSION}"
+  fi
+
+  # Verify installation
+  echo ""
+  if command -v cm &>/dev/null; then
+    local installed_version
+    installed_version=$(cm --version 2>/dev/null || echo "unknown")
+    ok "CodyMaster installed successfully!"
+    echo ""
+    echo -e "  ${BOLD}Version:${RESET}  v${installed_version}"
+    echo -e "  ${BOLD}Command:${RESET}  cm --help"
+    echo -e "  ${BOLD}Docs:${RESET}     https://github.com/todyle/codymaster"
+    echo ""
+    echo -e "  ${BOLD}Quick start:${RESET}"
+    echo -e "    cm status          Show project summary"
+    echo -e "    cm task add \"...\"   Create a task"
+    echo -e "    cm dashboard       Start dashboard"
+    echo ""
+  else
+    warn "cm command not found in PATH. You may need to restart your shell:"
+    echo ""
+    echo "  # For bash/zsh:"
+    echo "  source ~/.bashrc  # or source ~/.zshrc"
+    echo ""
+    echo "  # Or add npm global bin to PATH:"
+    echo "  export PATH=\"\$(npm config get prefix)/bin:\$PATH\""
+    echo ""
+  fi
+}
+
+main

package/scripts/mcp-bridge.js

@@ -89,7 +89,7 @@ async function cmSyncTodos({ todos, projectName, sessionId }) {
       dashboardRequest('POST', '/api/tasks/auto-sync', {
         conversationId: `${sid}:${todo.id}`,
         title: todo.content,
-        status: STATUS_TO_COLUMN[todo.status] || 'backlog',
+        status: todo.status || 'pending',  // Send original status, not mapped column
         agent: 'claude-code',
         priority: todo.priority || 'medium',
         projectName: project,
@@ -124,7 +124,7 @@ async function cmUpdateTask({ conversationId, status, title, projectName }) {
   const result = await dashboardRequest('POST', '/api/tasks/auto-sync', {
     conversationId: conversationId || `mcp-${Date.now()}:manual`,
     title: title || conversationId,
-    status: STATUS_TO_COLUMN[status] || 'in-progress',
+    status: status || 'in_progress',  // Send original status, not mapped column
     agent: 'claude-code',
     projectName: projectName || 'Claude Desktop',
   });