@wipcomputer/wip-release 1.2.4 → 1.9.7

package/CHANGELOG.md

@@ -3,9 +3,6 @@
 
 
 
-
-
-
 ## 1.2.4 (2026-02-21)
 
 Align description across all sources

package/LICENSE

@@ -1,6 +1,10 @@
-MIT License
+Dual License: MIT + AGPLv3
 
-Copyright (c) 2026 Parker Todd Brooks
+Copyright (c) 2026 WIP Computer, Inc.
+
+
+1. MIT License (local and personal use)
+---------------------------------------
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -19,3 +23,30 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
+
+
+2. GNU Affero General Public License v3.0 (commercial and cloud use)
+--------------------------------------------------------------------
+
+If you run this software as part of a hosted service, cloud platform,
+marketplace listing, or any network-accessible offering for commercial
+purposes, the AGPLv3 terms apply. You must either:
+
+  a) Release your complete source code under AGPLv3, or
+  b) Obtain a commercial license.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published
+by the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+
+AGPLv3 for personal use is free. Commercial licenses available.

package/README.md

@@ -6,7 +6,7 @@
 
 You ship a fix. Now you have to bump package.json, update CHANGELOG.md, sync the version in SKILL.md, commit, tag, push, publish to npm, publish to GitHub Packages, and create a GitHub release. Every time. Miss a step and versions drift.
 
-`wip-release` does all of it in one command.
+`wip-release` does all of it in one command. It also checks that product docs (dev update, roadmap, readme-first) are up to date before publishing. Patches get a warning. Minor and major releases are blocked until docs are updated.
 
 ## Install
 
@@ -35,6 +35,11 @@ See [REFERENCE.md](REFERENCE.md) for full usage, pipeline steps, flags, auth, an
 
 ## License
 
-MIT
+```
+CLI, MCP server, skills                        MIT    (use anywhere, no restrictions)
+Hosted or cloud service use                    AGPL   (network service distribution)
+```
+
+AGPL for personal use is free.
 
-Built by Parker Todd Brooks, with Claude Code and Lēsa (OpenClaw).
+Built by Parker Todd Brooks, Lēsa (OpenClaw, Claude Opus 4.6), Claude Code (Claude Opus 4.6).

package/SKILL.md

@@ -1,9 +1,13 @@
 ---
-name: WIP.release
-version: 1.2.4
+name: wip-release
 description: One-command release pipeline. Bumps version, updates changelog + SKILL.md, publishes to npm + GitHub.
-homepage: https://github.com/wipcomputer/wip-release
+license: MIT
+interface: [cli, module, mcp]
 metadata:
+  display-name: "Release Pipeline"
+  version: "1.2.4"
+  homepage: "https://github.com/wipcomputer/wip-release"
+  author: "Parker Todd Brooks"
   category: dev-tools
   capabilities:
     - version-bump
@@ -11,22 +15,25 @@ metadata:
     - skill-sync
     - npm-publish
     - github-release
-  dependencies: []
-  interface: CLI
   requires:
-    binaries: [git, npm, gh, op, clawhub]
+    bins: [git, npm, gh, op, clawhub]
     secrets:
       - path: ~/.openclaw/secrets/op-sa-token
         description: 1Password service account token
       - vault: Agent Secrets
         item: npm Token
         description: npm publish token
-openclaw:
-  emoji: "🚀"
-  install:
-    env: []
-author:
-  name: Parker Todd Brooks
+  openclaw:
+    requires:
+      bins: [git, npm, gh, op]
+    install:
+      - id: node
+        kind: node
+        package: "@wipcomputer/wip-release"
+        bins: [wip-release]
+        label: "Install via npm"
+    emoji: "🚀"
+compatibility: Requires git, npm, gh, op (1Password CLI). Node.js 18+.
 ---
 
 # wip-release
@@ -56,11 +63,25 @@ Local release pipeline. One command bumps version, updates all docs, publishes e
 ### CLI
 
 ```bash
-wip-release patch --notes="fix X"    # full pipeline
-wip-release minor --dry-run          # preview only
-wip-release major --no-publish       # bump + tag only
+wip-release patch --notes="fix X"           # full pipeline
+wip-release minor --dry-run                 # preview only
+wip-release major --no-publish              # bump + tag only
+wip-release patch --skip-product-check      # skip product docs gate
 ```
 
+### Product Docs Gate
+
+wip-release checks that product docs (dev update, roadmap, readme-first) were updated before publishing. Only runs on repos with an `ai/` directory.
+
+- **patch**: warns if product docs are stale (non-blocking)
+- **minor/major**: blocks release until product docs are updated
+- **--skip-product-check**: bypasses the gate
+
+Checks:
+1. `ai/dev-updates/` has a file from the last 3 days
+2. `ai/product/plans-prds/roadmap.md` was modified since last release
+3. `ai/product/readme-first-product.md` was modified since last release
+
 ### Module
 
 ```javascript
@@ -79,3 +100,17 @@ Branch protection may prevent direct pushes. Make sure you're on main after merg
 
 ### SKILL.md not updated
 Only updates if the file has a YAML frontmatter `version:` field between `---` markers.
+
+## MCP
+
+Tools: `release`, `release_status`
+
+Add to `.mcp.json`:
+```json
+{
+  "wip-release": {
+    "command": "node",
+    "args": ["/path/to/tools/wip-release/mcp-server.mjs"]
+  }
+}
+```

package/cli.js

@@ -18,7 +18,69 @@ function flag(name) {
 
 const dryRun = args.includes('--dry-run');
 const noPublish = args.includes('--no-publish');
-const notes = flag('notes');
+const skipProductCheck = args.includes('--skip-product-check');
+const skipStaleCheck = args.includes('--skip-stale-check');
+const notesFilePath = flag('notes-file');
+let notes = flag('notes');
+let notesSource = notes ? 'flag' : 'none'; // track where notes came from
+
+// Auto-detect RELEASE-NOTES-v{version}.md if no --notes or --notes-file provided.
+// Also supports explicit --notes-file for custom paths.
+{
+  const { readFileSync, existsSync } = await import('node:fs');
+  const { resolve, join } = await import('node:path');
+
+  if (notesFilePath) {
+    // Explicit --notes-file
+    const resolved = resolve(notesFilePath);
+    if (!existsSync(resolved)) {
+      console.error(`  ✗ Notes file not found: ${resolved}`);
+      process.exit(1);
+    }
+    notes = readFileSync(resolved, 'utf8').trim();
+    notesSource = 'file';
+  } else if (!notes && level) {
+    // Auto-detect: compute the next version and look for RELEASE-NOTES-v{version}.md
+    try {
+      const { detectCurrentVersion, bumpSemver } = await import('./core.mjs');
+      const cwd = process.cwd();
+      const currentVersion = detectCurrentVersion(cwd);
+      const newVersion = bumpSemver(currentVersion, level);
+      const dashed = newVersion.replace(/\./g, '-');
+      const autoFile = join(cwd, `RELEASE-NOTES-v${dashed}.md`);
+      if (existsSync(autoFile)) {
+        notes = readFileSync(autoFile, 'utf8').trim();
+        notesSource = 'file';
+        console.log(`  ✓ Found RELEASE-NOTES-v${dashed}.md`);
+      }
+    } catch {}
+  }
+
+  // Auto-detect dev update from ai/dev-updates/ if notes are missing or thin
+  if (level && (!notes || notes.length < 100)) {
+    try {
+      const { readdirSync } = await import('node:fs');
+      const devUpdatesDir = join(process.cwd(), 'ai', 'dev-updates');
+      if (existsSync(devUpdatesDir)) {
+        const today = new Date().toISOString().split('T')[0];
+        const todayFiles = readdirSync(devUpdatesDir)
+          .filter(f => f.startsWith(today) && f.endsWith('.md'))
+          .sort()
+          .reverse();
+
+        if (todayFiles.length > 0) {
+          const devUpdatePath = join(devUpdatesDir, todayFiles[0]);
+          const devUpdateContent = readFileSync(devUpdatePath, 'utf8').trim();
+          if (devUpdateContent.length > (notes || '').length) {
+            notes = devUpdateContent;
+            notesSource = 'dev-update';
+            console.log(`  ✓ Found dev update: ai/dev-updates/${todayFiles[0]}`);
+          }
+        }
+      }
+    } catch {}
+  }
+}
 
 if (!level || args.includes('--help') || args.includes('-h')) {
   const cwd = process.cwd();
@@ -33,9 +95,19 @@ Usage:
   wip-release major                    1.0.0 -> 2.0.0
 
 Flags:
-  --notes="description"    Changelog entry text
+  --notes="description"    Release narrative (what was built and why)
+  --notes-file=path        Read release narrative from a markdown file
   --dry-run                Show what would happen, change nothing
   --no-publish             Bump + tag only, skip npm/GitHub
+  --skip-product-check     Skip product docs check (dev update, roadmap, readme-first)
+  --skip-stale-check       Skip stale remote branch check
+
+Release notes:
+  Auto-detects notes from three sources (first match wins):
+  1. --notes-file=path          Explicit file path
+  2. RELEASE-NOTES-v{ver}.md    In repo root (e.g. RELEASE-NOTES-v1-7-4.md)
+  3. ai/dev-updates/YYYY-MM-DD* Today's dev update files (most recent first)
+  Write dev updates as you work. wip-release picks them up automatically.
 
 Pipeline:
   1. Bump package.json version
@@ -53,8 +125,11 @@ release({
   repoPath: process.cwd(),
   level,
   notes,
+  notesSource,
   dryRun,
   noPublish,
+  skipProductCheck,
+  skipStaleCheck,
 }).catch(err => {
   console.error(`  ✗ ${err.message}`);
   process.exit(1);

package/core.mjs

@@ -6,7 +6,7 @@
  */
 
 import { execSync, execFileSync } from 'node:child_process';
-import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { readFileSync, writeFileSync, existsSync, readdirSync, mkdirSync, renameSync } from 'node:fs';
 import { join, basename } from 'node:path';
 
 // ── Version ─────────────────────────────────────────────────────────
@@ -54,10 +54,27 @@ export function syncSkillVersion(repoPath, newVersion) {
   if (!existsSync(skillPath)) return false;
 
   let content = readFileSync(skillPath, 'utf8');
-  // Match version: X.Y.Z in YAML frontmatter (between --- markers)
+
+  // Check for staleness: if SKILL.md version is more than a patch behind,
+  // warn that content may need updating (not just the version number)
+  const skillVersionMatch = content.match(/^---[\s\S]*?version:\s*"?(\d+\.\d+\.\d+)"?[\s\S]*?---/);
+  if (skillVersionMatch) {
+    const skillVersion = skillVersionMatch[1];
+    const [sMaj, sMin] = skillVersion.split('.').map(Number);
+    const [nMaj, nMin] = newVersion.split('.').map(Number);
+    if (nMaj > sMaj || nMin > sMin + 1) {
+      console.warn(`  ! SKILL.md is at ${skillVersion}, releasing ${newVersion}`);
+      console.warn(`    SKILL.md content may be stale. Review tool list and interfaces.`);
+    }
+  }
+
+  // Match version line in YAML frontmatter (between --- markers).
+  // Uses "[^\n]* for quoted values (including corrupted multi-quote strings
+  // like "1.9.5".9.4".9.3") or \S+ for unquoted values. This replaces the
+  // ENTIRE value on the line, preventing the accumulation bug (#71).
   const updated = content.replace(
-    /^(---[\s\S]*?)(version:\s*)\S+([\s\S]*?---)/,
-    `$1$2${newVersion}$3`
+    /^(---[\s\S]*?version:\s*)(?:"[^\n]*|\S+)([\s\S]*?---)/,
+    `$1"${newVersion}"$2`
   );
 
   if (updated === content) return false;
@@ -95,6 +112,25 @@ export function updateChangelog(repoPath, newVersion, notes) {
 
 // ── Git ─────────────────────────────────────────────────────────────
 
+/**
+ * Move all RELEASE-NOTES-v*.md files to _trash/.
+ * Returns the number of files moved.
+ */
+function trashReleaseNotes(repoPath) {
+  const files = readdirSync(repoPath).filter(f => /^RELEASE-NOTES-v.*\.md$/i.test(f));
+  if (files.length === 0) return 0;
+
+  const trashDir = join(repoPath, '_trash');
+  if (!existsSync(trashDir)) mkdirSync(trashDir);
+
+  for (const f of files) {
+    renameSync(join(repoPath, f), join(trashDir, f));
+    execFileSync('git', ['add', join('_trash', f)], { cwd: repoPath, stdio: 'pipe' });
+    execFileSync('git', ['rm', '--cached', f], { cwd: repoPath, stdio: 'pipe' });
+  }
+  return files.length;
+}
+
 function gitCommitAndTag(repoPath, newVersion, notes) {
   const msg = `v${newVersion}: ${notes || 'Release'}`;
   // Stage known files (ignore missing ones)
@@ -134,55 +170,223 @@ export function publishGitHubPackages(repoPath) {
 }
 
 /**
- * Build detailed release notes from git history and repo metadata.
+ * Categorize a commit message into a section.
+ * Returns: 'changes', 'fixes', 'docs', 'internal'
+ */
+function categorizeCommit(subject) {
+  const lower = subject.toLowerCase();
+
+  // Fixes
+  if (lower.startsWith('fix') || lower.startsWith('hotfix') || lower.startsWith('bugfix') ||
+      lower.includes('fix:') || lower.includes('bug:')) {
+    return 'fixes';
+  }
+
+  // Docs
+  if (lower.startsWith('doc') || lower.startsWith('readme') ||
+      lower.includes('docs:') || lower.includes('doc:') ||
+      lower.startsWith('update readme') || lower.startsWith('rewrite readme') ||
+      lower.startsWith('update technical') || lower.startsWith('rewrite relay') ||
+      lower.startsWith('update relay')) {
+    return 'docs';
+  }
+
+  // Internal (skip in release notes)
+  if (lower.startsWith('chore') || lower.startsWith('auto-commit') ||
+      lower.startsWith('merge pull request') || lower.startsWith('merge branch') ||
+      lower.match(/^v\d+\.\d+\.\d+/) || lower.startsWith('mark ') ||
+      lower.startsWith('clean up todo') || lower.startsWith('keep ')) {
+    return 'internal';
+  }
+
+  // Everything else is a change
+  return 'changes';
+}
+
+/**
+ * Check release notes quality. Returns { ok, issues[] }.
+ *
+ * notesSource: 'file' (RELEASE-NOTES-v*.md or --notes-file),
+ *              'dev-update' (ai/dev-updates/ fallback),
+ *              'flag' (bare --notes="string"),
+ *              'none' (nothing provided).
+ *
+ * For minor/major: BLOCKS if notes came from bare --notes flag or are missing.
+ *   Agents must write a RELEASE-NOTES-v{version}.md file and commit it.
+ * For patch: WARNS only.
+ */
+function checkReleaseNotes(notes, notesSource, level) {
+  const issues = [];
+  const isMinorOrMajor = level === 'minor' || level === 'major';
+
+  if (!notes) {
+    issues.push('No release notes provided. Write a RELEASE-NOTES-v{version}.md file.');
+    return { ok: false, issues };
+  }
+
+  // Bare --notes flag is not acceptable for minor/major.
+  // Agents must write a file, not pass a one-liner.
+  if (notesSource === 'flag') {
+    if (isMinorOrMajor) {
+      issues.push('Release notes came from --notes flag, not a file.');
+      issues.push('Write RELEASE-NOTES-v{version}.md (dashes not dots) and commit it.');
+      issues.push('wip-release auto-detects the file. No --notes flag needed.');
+    } else if (notes.length < 50) {
+      issues.push('Release notes are very short. Consider writing a RELEASE-NOTES file.');
+    }
+  }
+
+  // Check for changelog-style one-liners regardless of source
+  const looksLikeChangelog = /^(fix|add|update|remove|bump|chore|refactor|docs?)[\s:]/i.test(notes);
+  if (looksLikeChangelog && notes.length < 100) {
+    issues.push('Notes look like a changelog entry, not a narrative.');
+  }
+
+  return { ok: issues.length === 0, issues };
+}
+
+/**
+ * Check if a file was modified in commits since the last git tag.
+ */
+function fileModifiedSinceLastTag(repoPath, relativePath) {
+  try {
+    const lastTag = execFileSync('git', ['describe', '--tags', '--abbrev=0'],
+      { cwd: repoPath, encoding: 'utf8' }).trim();
+    const diff = execFileSync('git', ['diff', '--name-only', lastTag, 'HEAD'],
+      { cwd: repoPath, encoding: 'utf8' });
+    return diff.split('\n').some(f => f.trim() === relativePath);
+  } catch {
+    // No tags yet or git error ... skip check
+    return true;
+  }
+}
+
+/**
+ * Check that product docs were updated for this release.
+ * Returns { missing: string[], ok: boolean, skipped: boolean }.
+ * Only runs if ai/ directory structure exists.
+ */
+function checkProductDocs(repoPath) {
+  const missing = [];
+
+  // Skip repos without ai/ structure
+  const aiDir = join(repoPath, 'ai');
+  if (!existsSync(aiDir)) return { missing: [], ok: true, skipped: true };
+
+  // 1. Dev update: file from today (or last 3 days)
+  const devUpdatesDir = join(aiDir, 'dev-updates');
+  if (existsSync(devUpdatesDir)) {
+    const now = new Date();
+    const recentDates = [];
+    for (let i = 0; i < 3; i++) {
+      const d = new Date(now);
+      d.setDate(d.getDate() - i);
+      recentDates.push(d.toISOString().split('T')[0]);
+    }
+    const files = readdirSync(devUpdatesDir).filter(f => f.endsWith('.md'));
+    const hasRecent = files.some(f => recentDates.some(d => f.startsWith(d)));
+    if (!hasRecent) missing.push('ai/dev-updates/ (no dev update from last 3 days)');
+  }
+
+  // 2. Roadmap: modified since last tag
+  const roadmapPath = 'ai/product/plans-prds/roadmap.md';
+  if (existsSync(join(repoPath, roadmapPath))) {
+    if (!fileModifiedSinceLastTag(repoPath, roadmapPath)) {
+      missing.push('ai/product/plans-prds/roadmap.md (not updated since last release)');
+    }
+  }
+
+  // 3. Readme-first: modified since last tag
+  const readmeFirstPath = 'ai/product/readme-first-product.md';
+  if (existsSync(join(repoPath, readmeFirstPath))) {
+    if (!fileModifiedSinceLastTag(repoPath, readmeFirstPath)) {
+      missing.push('ai/product/readme-first-product.md (not updated since last release)');
+    }
+  }
+
+  return { missing, ok: missing.length === 0, skipped: false };
+}
+
+/**
+ * Build release notes with narrative first, commit details second.
+ *
+ * Release notes should tell the story: what was built, why, and why it matters.
+ * Commit history is included as supporting detail, not the main content.
+ * ai/ files are excluded from the files-changed stats.
  */
 export function buildReleaseNotes(repoPath, currentVersion, newVersion, notes) {
   const slug = detectRepoSlug(repoPath);
   const pkg = JSON.parse(readFileSync(join(repoPath, 'package.json'), 'utf8'));
   const lines = [];
 
-  // What changed section
-  lines.push('## What changed\n');
+  // Narrative summary (the main content of the release notes)
   if (notes) {
     lines.push(notes);
     lines.push('');
   }
 
-  // Commits since last tag
+  // Gather commits since last tag
   const prevTag = `v${currentVersion}`;
-  let commits = '';
+  let rawCommits = [];
   try {
-    commits = execFileSync('git', [
-      'log', `${prevTag}..HEAD`, '--pretty=format:- %s (%h)'
+    const raw = execFileSync('git', [
+      'log', `${prevTag}..HEAD`, '--pretty=format:%h\t%s'
     ], { cwd: repoPath, encoding: 'utf8' }).trim();
+    if (raw) rawCommits = raw.split('\n').map(line => {
+      const [hash, ...rest] = line.split('\t');
+      return { hash, subject: rest.join('\t') };
+    });
   } catch {
-    // No previous tag ... show all commits on branch
     try {
-      commits = execFileSync('git', [
-        'log', '--pretty=format:- %s (%h)', '-20'
+      const raw = execFileSync('git', [
+        'log', '--pretty=format:%h\t%s', '-30'
       ], { cwd: repoPath, encoding: 'utf8' }).trim();
+      if (raw) rawCommits = raw.split('\n').map(line => {
+        const [hash, ...rest] = line.split('\t');
+        return { hash, subject: rest.join('\t') };
+      });
     } catch {}
   }
 
-  if (commits) {
-    lines.push('### Commits\n');
-    lines.push(commits);
-    lines.push('');
+  // Categorize commits
+  const categories = { changes: [], fixes: [], docs: [], internal: [] };
+  for (const commit of rawCommits) {
+    const cat = categorizeCommit(commit.subject);
+    categories[cat].push(commit);
   }
 
-  // Files changed
-  let filesChanged = '';
-  try {
-    filesChanged = execFileSync('git', [
-      'diff', `${prevTag}..HEAD`, '--stat'
-    ], { cwd: repoPath, encoding: 'utf8' }).trim();
-  } catch {}
+  // Commit details section (supporting detail, not the headline)
+  const hasCommits = categories.changes.length + categories.fixes.length + categories.docs.length > 0;
+  if (hasCommits) {
+    lines.push('<details>');
+    lines.push('<summary>What changed (commits)</summary>');
+    lines.push('');
+
+    if (categories.changes.length > 0) {
+      lines.push('**Changes**');
+      for (const c of categories.changes) {
+        lines.push(`- ${c.subject} (${c.hash})`);
+      }
+      lines.push('');
+    }
+
+    if (categories.fixes.length > 0) {
+      lines.push('**Fixes**');
+      for (const c of categories.fixes) {
+        lines.push(`- ${c.subject} (${c.hash})`);
+      }
+      lines.push('');
+    }
+
+    if (categories.docs.length > 0) {
+      lines.push('**Docs**');
+      for (const c of categories.docs) {
+        lines.push(`- ${c.subject} (${c.hash})`);
+      }
+      lines.push('');
+    }
 
-  if (filesChanged) {
-    lines.push('### Files changed\n');
-    lines.push('```');
-    lines.push(filesChanged);
-    lines.push('```');
+    lines.push('</details>');
     lines.push('');
   }
 
@@ -198,9 +402,13 @@ export function buildReleaseNotes(repoPath, currentVersion, newVersion, notes) {
   lines.push('```');
   lines.push('');
 
+  // Attribution
+  lines.push('---');
+  lines.push('');
+  lines.push('Built by Parker Todd Brooks, Lēsa (OpenClaw, Claude Opus 4.6), Claude Code (Claude Opus 4.6).');
+
   // Compare URL
   if (slug) {
-    lines.push('---');
     lines.push('');
     lines.push(`Full changelog: https://github.com/${slug}/compare/v${currentVersion}...v${newVersion}`);
   }
@@ -264,8 +472,18 @@ function getNpmToken() {
 }
 
 function detectSkillSlug(repoPath) {
-  // Slug must be lowercase and url-safe. Use directory name, not SKILL.md name
-  // (SKILL.md name can be display-formatted like "WIP.release").
+  // Read the name field from SKILL.md frontmatter (agentskills.io spec: lowercase-hyphen slug).
+  // Falls back to directory name.
+  const skillPath = join(repoPath, 'SKILL.md');
+  if (existsSync(skillPath)) {
+    const content = readFileSync(skillPath, 'utf8');
+    const nameMatch = content.match(/^---[\s\S]*?\nname:\s*(.+?)\n/);
+    if (nameMatch) {
+      const name = nameMatch[1].trim().replace(/^["']|["']$/g, '');
+      // Only use if it looks like a slug (lowercase, hyphens)
+      if (/^[a-z][a-z0-9-]*$/.test(name)) return name;
+    }
+  }
   return basename(repoPath).toLowerCase();
 }
 
@@ -280,12 +498,61 @@ function detectRepoSlug(repoPath) {
   }
 }
 
+// ── Stale Branch Check ──────────────────────────────────────────────
+
+/**
+ * Check for remote branches that are already merged into origin/main.
+ * These should be cleaned up before releasing.
+ *
+ * For patch: WARN (non-blocking, just print stale branches).
+ * For minor/major: BLOCK (return { failed: true }).
+ *
+ * Filters out origin/main, origin/HEAD, and already-renamed --merged- branches.
+ */
+export function checkStaleBranches(repoPath, level) {
+  try {
+    // Fetch latest remote state so --merged check is accurate
+    try {
+      execFileSync('git', ['fetch', '--prune'], { cwd: repoPath, stdio: 'pipe' });
+    } catch {
+      // Non-fatal: proceed with local state if fetch fails
+    }
+
+    const raw = execFileSync('git', ['branch', '-r', '--merged', 'origin/main'], {
+      cwd: repoPath, encoding: 'utf8'
+    }).trim();
+
+    if (!raw) return { stale: [], ok: true };
+
+    const stale = raw.split('\n')
+      .map(b => b.trim())
+      .filter(b =>
+        b &&
+        !b.includes('origin/main') &&
+        !b.includes('origin/HEAD') &&
+        !b.includes('--merged-')
+      );
+
+    if (stale.length === 0) return { stale: [], ok: true };
+
+    const isMinorOrMajor = level === 'minor' || level === 'major';
+    return {
+      stale,
+      ok: !isMinorOrMajor,
+      blocked: isMinorOrMajor,
+    };
+  } catch {
+    // Git command failed... skip check gracefully
+    return { stale: [], ok: true, skipped: true };
+  }
+}
+
 // ── Main ────────────────────────────────────────────────────────────
 
 /**
  * Run the full release pipeline.
  */
-export async function release({ repoPath, level, notes, dryRun, noPublish }) {
+export async function release({ repoPath, level, notes, notesSource, dryRun, noPublish, skipProductCheck, skipStaleCheck }) {
   repoPath = repoPath || process.cwd();
   const currentVersion = detectCurrentVersion(repoPath);
   const newVersion = bumpSemver(currentVersion, level);
@@ -295,7 +562,149 @@ export async function release({ repoPath, level, notes, dryRun, noPublish }) {
   console.log(`  ${repoName}: ${currentVersion} -> ${newVersion} (${level})`);
   console.log(`  ${'─'.repeat(40)}`);
 
+  // 0. License compliance gate
+  const configPath = join(repoPath, '.license-guard.json');
+  if (existsSync(configPath)) {
+    const config = JSON.parse(readFileSync(configPath, 'utf8'));
+    const licenseIssues = [];
+
+    const licensePath = join(repoPath, 'LICENSE');
+    if (!existsSync(licensePath)) {
+      licenseIssues.push('LICENSE file is missing');
+    } else {
+      const licenseText = readFileSync(licensePath, 'utf8');
+      if (!licenseText.includes(config.copyright)) {
+        licenseIssues.push(`LICENSE copyright does not match "${config.copyright}"`);
+      }
+      if (config.license === 'MIT+AGPL' && !licenseText.includes('AGPL') && !licenseText.includes('GNU Affero')) {
+        licenseIssues.push('LICENSE is MIT-only but config requires MIT+AGPL');
+      }
+    }
+
+    if (!existsSync(join(repoPath, 'CLA.md'))) {
+      licenseIssues.push('CLA.md is missing');
+    }
+
+    const readmePath = join(repoPath, 'README.md');
+    if (existsSync(readmePath)) {
+      const readme = readFileSync(readmePath, 'utf8');
+      if (!readme.includes('## License')) licenseIssues.push('README.md missing ## License section');
+      if (config.license === 'MIT+AGPL' && !readme.includes('AGPL')) licenseIssues.push('README.md License section missing AGPL reference');
+    }
+
+    if (licenseIssues.length > 0) {
+      console.log(`  ✗ License compliance failed:`);
+      for (const issue of licenseIssues) console.log(`    - ${issue}`);
+      console.log(`\n  Run \`wip-license-guard check --fix\` to auto-repair, then try again.`);
+      console.log('');
+      return { currentVersion, newVersion, dryRun: false, failed: true };
+    }
+    console.log(`  ✓ License compliance passed`);
+  }
+
+  // 0.5. Product docs check
+  if (!skipProductCheck) {
+    const productCheck = checkProductDocs(repoPath);
+    if (!productCheck.skipped) {
+      if (productCheck.ok) {
+        console.log('  ✓ Product docs up to date');
+      } else {
+        const isMinorOrMajor = level === 'minor' || level === 'major';
+        const prefix = isMinorOrMajor ? '✗' : '!';
+        console.log(`  ${prefix} Product docs need attention:`);
+        for (const m of productCheck.missing) console.log(`    - ${m}`);
+        if (isMinorOrMajor) {
+          console.log('');
+          console.log('  Update product docs before a minor/major release.');
+          console.log('  Use --skip-product-check to override.');
+          console.log('');
+          return { currentVersion, newVersion, dryRun: false, failed: true };
+        }
+      }
+    }
+  }
+
+  // 0.75. Release notes quality gate
+  {
+    const notesCheck = checkReleaseNotes(notes, notesSource || 'flag', level);
+    if (notesCheck.ok) {
+      const sourceLabel = notesSource === 'file' ? 'from file' : notesSource === 'dev-update' ? 'from dev update' : 'from --notes';
+      console.log(`  ✓ Release notes OK (${sourceLabel})`);
+    } else {
+      const isMinorOrMajor = level === 'minor' || level === 'major';
+      const prefix = isMinorOrMajor ? '✗' : '!';
+      console.log(`  ${prefix} Release notes need attention:`);
+      for (const issue of notesCheck.issues) console.log(`    - ${issue}`);
+      if (isMinorOrMajor) {
+        console.log('');
+        console.log('  Minor/major releases require a RELEASE-NOTES file, not a --notes one-liner.');
+        console.log('  Write RELEASE-NOTES-v{version}.md (dashes not dots), commit it, then release.');
+        console.log('');
+        return { currentVersion, newVersion, dryRun: false, failed: true };
+      }
+    }
+  }
+
+  // 0.8. Stale remote branch check
+  if (!skipStaleCheck) {
+    const staleCheck = checkStaleBranches(repoPath, level);
+    if (staleCheck.skipped) {
+      // Silently skip if git command failed
+    } else if (staleCheck.stale.length === 0) {
+      console.log('  ✓ No stale remote branches');
+    } else {
+      const isMinorOrMajor = level === 'minor' || level === 'major';
+      const prefix = isMinorOrMajor ? '✗' : '!';
+      console.log(`  ${prefix} Stale remote branches merged into main:`);
+      for (const b of staleCheck.stale) console.log(`    - ${b}`);
+      if (isMinorOrMajor) {
+        console.log('');
+        console.log('  Clean up stale branches before a minor/major release.');
+        console.log('  Delete them with: git push origin --delete <branch>');
+        console.log('  Use --skip-stale-check to override.');
+        console.log('');
+        return { currentVersion, newVersion, dryRun: false, failed: true };
+      }
+    }
+  }
+
   if (dryRun) {
+    // Product docs check (dry-run)
+    if (!skipProductCheck) {
+      const productCheck = checkProductDocs(repoPath);
+      if (!productCheck.skipped) {
+        if (productCheck.ok) {
+          console.log('  [dry run] ✓ Product docs up to date');
+        } else {
+          const isMinorOrMajor = level === 'minor' || level === 'major';
+          console.log(`  [dry run] ${isMinorOrMajor ? '✗ Would BLOCK' : '! Would WARN'}: product docs need updates`);
+          for (const m of productCheck.missing) console.log(`    - ${m}`);
+        }
+      }
+    }
+    // Release notes check (dry-run)
+    {
+      const notesCheck = checkReleaseNotes(notes, notesSource || 'flag', level);
+      if (notesCheck.ok) {
+        const sourceLabel = notesSource === 'file' ? 'from file' : notesSource === 'dev-update' ? 'from dev update' : 'from --notes';
+        console.log(`  [dry run] ✓ Release notes OK (${sourceLabel})`);
+      } else {
+        const isMinorOrMajor = level === 'minor' || level === 'major';
+        console.log(`  [dry run] ${isMinorOrMajor ? '✗ Would BLOCK' : '! Would WARN'}: release notes need attention`);
+        for (const issue of notesCheck.issues) console.log(`    - ${issue}`);
+      }
+    }
+    // Stale branch check (dry-run)
+    if (!skipStaleCheck) {
+      const staleCheck = checkStaleBranches(repoPath, level);
+      if (!staleCheck.skipped && staleCheck.stale.length > 0) {
+        const isMinorOrMajor = level === 'minor' || level === 'major';
+        console.log(`  [dry run] ${isMinorOrMajor ? '✗ Would BLOCK' : '! Would WARN'}: stale remote branches`);
+        for (const b of staleCheck.stale) console.log(`    - ${b}`);
+      } else if (!staleCheck.skipped) {
+        console.log('  [dry run] ✓ No stale remote branches');
+      }
+    }
     const hasSkill = existsSync(join(repoPath, 'SKILL.md'));
     console.log(`  [dry run] Would bump package.json to ${newVersion}`);
     if (hasSkill) console.log(`  [dry run] Would update SKILL.md version`);
@@ -317,6 +726,30 @@ export async function release({ repoPath, level, notes, dryRun, noPublish }) {
   writePackageVersion(repoPath, newVersion);
   console.log(`  ✓ package.json -> ${newVersion}`);
 
+  // 1.5. Bump sub-tool versions in toolbox repos (tools/*/)
+  const toolsDir = join(repoPath, 'tools');
+  if (existsSync(toolsDir)) {
+    let subBumped = 0;
+    try {
+      const entries = readdirSync(toolsDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const subPkgPath = join(toolsDir, entry.name, 'package.json');
+        if (existsSync(subPkgPath)) {
+          try {
+            const subPkg = JSON.parse(readFileSync(subPkgPath, 'utf8'));
+            subPkg.version = newVersion;
+            writeFileSync(subPkgPath, JSON.stringify(subPkg, null, 2) + '\n');
+            subBumped++;
+          } catch {}
+        }
+      }
+    } catch {}
+    if (subBumped > 0) {
+      console.log(`  ✓ ${subBumped} sub-tool(s) -> ${newVersion}`);
+    }
+  }
+
   // 2. Sync SKILL.md
   if (syncSkillVersion(repoPath, newVersion)) {
     console.log(`  ✓ SKILL.md -> ${newVersion}`);
@@ -326,6 +759,12 @@ export async function release({ repoPath, level, notes, dryRun, noPublish }) {
   updateChangelog(repoPath, newVersion, notes);
   console.log(`  ✓ CHANGELOG.md updated`);
 
+  // 3.5. Move RELEASE-NOTES-v*.md to _trash/
+  const trashed = trashReleaseNotes(repoPath);
+  if (trashed > 0) {
+    console.log(`  ✓ Moved ${trashed} RELEASE-NOTES file(s) to _trash/`);
+  }
+
   // 4. Git commit + tag
   gitCommitAndTag(repoPath, newVersion, notes);
   console.log(`  ✓ Committed and tagged v${newVersion}`);
@@ -338,41 +777,205 @@ export async function release({ repoPath, level, notes, dryRun, noPublish }) {
     console.log(`  ! Push failed (maybe branch protection). Push manually.`);
   }
 
+  // Distribution results collector (#104)
+  const distResults = [];
+
   if (!noPublish) {
     // 6. npm publish
     try {
       publishNpm(repoPath);
+      const pkg = JSON.parse(readFileSync(join(repoPath, 'package.json'), 'utf8'));
+      distResults.push({ target: 'npm', status: 'ok', detail: `${pkg.name}@${newVersion}` });
       console.log(`  ✓ Published to npm`);
     } catch (e) {
+      distResults.push({ target: 'npm', status: 'failed', detail: e.message });
       console.log(`  ✗ npm publish failed: ${e.message}`);
     }
 
     // 7. GitHub Packages
     try {
       publishGitHubPackages(repoPath);
+      distResults.push({ target: 'GitHub Packages', status: 'ok', detail: `${newVersion}` });
       console.log(`  ✓ Published to GitHub Packages`);
     } catch (e) {
+      distResults.push({ target: 'GitHub Packages', status: 'failed', detail: e.message });
       console.log(`  ✗ GitHub Packages publish failed: ${e.message}`);
     }
 
     // 8. GitHub release
     try {
       createGitHubRelease(repoPath, newVersion, notes, currentVersion);
+      distResults.push({ target: 'GitHub', status: 'ok', detail: `v${newVersion}` });
       console.log(`  ✓ GitHub release v${newVersion} created`);
     } catch (e) {
+      distResults.push({ target: 'GitHub', status: 'failed', detail: e.message });
       console.log(`  ✗ GitHub release failed: ${e.message}`);
     }
 
-    // 9. ClawHub skill publish
-    const skillPath = join(repoPath, 'SKILL.md');
-    if (existsSync(skillPath)) {
+    // 9. ClawHub skill publish (root + sub-tools)
+    const rootSkill = join(repoPath, 'SKILL.md');
+    const toolsDir = join(repoPath, 'tools');
+
+    // Publish root SKILL.md
+    if (existsSync(rootSkill)) {
       try {
         publishClawHub(repoPath, newVersion, notes);
-        console.log(`  ✓ Published to ClawHub`);
+        const slug = detectSkillSlug(repoPath);
+        distResults.push({ target: `ClawHub`, status: 'ok', detail: `${slug}@${newVersion}` });
+        console.log(`  ✓ Published to ClawHub: ${slug}`);
       } catch (e) {
+        distResults.push({ target: 'ClawHub (root)', status: 'failed', detail: e.message });
         console.log(`  ✗ ClawHub publish failed: ${e.message}`);
       }
     }
+
+    // Publish each sub-tool SKILL.md (#97)
+    if (existsSync(toolsDir)) {
+      for (const tool of readdirSync(toolsDir)) {
+        const toolPath = join(toolsDir, tool);
+        const toolSkill = join(toolPath, 'SKILL.md');
+        if (existsSync(toolSkill)) {
+          try {
+            publishClawHub(toolPath, newVersion, notes);
+            const slug = detectSkillSlug(toolPath);
+            distResults.push({ target: `ClawHub`, status: 'ok', detail: `${slug}@${newVersion}` });
+            console.log(`  ✓ Published to ClawHub: ${slug}`);
+          } catch (e) {
+            const slug = detectSkillSlug(toolPath);
+            distResults.push({ target: `ClawHub (${slug})`, status: 'failed', detail: e.message });
+            console.log(`  ✗ ClawHub publish failed for ${slug}: ${e.message}`);
+          }
+        }
+      }
+    }
+  }
+
+  // Distribution summary (#104)
+  if (distResults.length > 0) {
+    console.log('');
+    console.log('  Distribution:');
+    for (const r of distResults) {
+      const icon = r.status === 'ok' ? '✓' : '✗';
+      console.log(`    ${icon} ${r.target}: ${r.detail}`);
+    }
+    const failed = distResults.filter(r => r.status !== 'ok');
+    if (failed.length > 0) {
+      console.log(`\n  ! ${failed.length} of ${distResults.length} target(s) failed.`);
+    }
+  }
+
+  // 10. Post-merge branch cleanup: rename merged branches with --merged-YYYY-MM-DD
+  try {
+    const merged = execSync(
+      'git branch --merged main', { cwd: repoPath, encoding: 'utf8' }
+    ).split('\n')
+      .map(b => b.trim())
+      .filter(b => b && b !== 'main' && b !== 'master' && !b.startsWith('*') && !b.includes('--merged-'));
+
+    if (merged.length > 0) {
+      console.log(`  Scanning ${merged.length} merged branch(es) for rename...`);
+      for (const branch of merged) {
+        const current = execSync('git branch --show-current', { cwd: repoPath, encoding: 'utf8' }).trim();
+        if (branch === current) continue;
+
+        let mergeDate;
+        try {
+          const mergeBase = execSync(`git merge-base main ${branch}`, { cwd: repoPath, encoding: 'utf8' }).trim();
+          mergeDate = execSync(
+            `git log main --format="%ai" --ancestry-path ${mergeBase}..main`,
+            { cwd: repoPath, encoding: 'utf8' }
+          ).trim().split('\n').pop().split(' ')[0];
+        } catch {}
+        if (!mergeDate) {
+          try {
+            mergeDate = execSync(`git log ${branch} -1 --format="%ai"`, { cwd: repoPath, encoding: 'utf8' }).trim().split(' ')[0];
+          } catch {}
+        }
+        if (!mergeDate) continue;
+
+        const newName = `${branch}--merged-${mergeDate}`;
+        try {
+          execSync(`git branch -m "${branch}" "${newName}"`, { cwd: repoPath, stdio: 'pipe' });
+          execSync(`git push origin "${newName}"`, { cwd: repoPath, stdio: 'pipe' });
+          execSync(`git push origin --delete "${branch}"`, { cwd: repoPath, stdio: 'pipe' });
+          console.log(`  ✓ Renamed: ${branch} -> ${newName}`);
+        } catch (e) {
+          console.log(`  ! Could not rename ${branch}: ${e.message}`);
+        }
+      }
+    }
+  } catch (e) {
+    // Non-fatal: branch cleanup is a convenience, not a blocker
+    console.log(`  ! Branch cleanup skipped: ${e.message}`);
+  }
+
+  // 11. Prune old merged branches (keep last 3 per developer prefix)
+  try {
+    const KEEP_COUNT = 3;
+    const remoteBranches = execSync(
+      'git branch -r', { cwd: repoPath, encoding: 'utf8' }
+    ).split('\n')
+      .map(b => b.trim())
+      .filter(b => b && !b.includes('HEAD') && b.includes('--merged-'))
+      .map(b => b.replace('origin/', ''));
+
+    if (remoteBranches.length > 0) {
+      // Group by developer prefix (everything before first /)
+      const byPrefix = {};
+      for (const branch of remoteBranches) {
+        const prefix = branch.split('/')[0];
+        if (!byPrefix[prefix]) byPrefix[prefix] = [];
+        byPrefix[prefix].push(branch);
+      }
+
+      let pruned = 0;
+      for (const [prefix, branches] of Object.entries(byPrefix)) {
+        // Sort by date descending (date is at the end: --merged-YYYY-MM-DD)
+        branches.sort((a, b) => {
+          const dateA = a.match(/--merged-(\d{4}-\d{2}-\d{2})/)?.[1] || '';
+          const dateB = b.match(/--merged-(\d{4}-\d{2}-\d{2})/)?.[1] || '';
+          return dateB.localeCompare(dateA);
+        });
+
+        for (let i = KEEP_COUNT; i < branches.length; i++) {
+          try {
+            execSync(`git push origin --delete "${branches[i]}"`, { cwd: repoPath, stdio: 'pipe' });
+            execSync(`git branch -d "${branches[i]}" 2>/dev/null || true`, { cwd: repoPath, stdio: 'pipe', shell: true });
+            pruned++;
+          } catch {}
+        }
+      }
+
+      if (pruned > 0) {
+        console.log(`  ✓ Pruned ${pruned} old merged branch(es)`);
+      }
+    }
+
+    // Clean stale branches (merged into main but never renamed)
+    const current = execSync('git branch --show-current', { cwd: repoPath, encoding: 'utf8' }).trim();
+    const allRemote = execSync(
+      'git branch -r', { cwd: repoPath, encoding: 'utf8' }
+    ).split('\n')
+      .map(b => b.trim())
+      .filter(b => b && !b.includes('HEAD') && !b.includes('origin/main') && !b.includes('--merged-'))
+      .map(b => b.replace('origin/', ''));
+
+    let staleCleaned = 0;
+    for (const branch of allRemote) {
+      if (branch === current) continue;
+      try {
+        execSync(`git merge-base --is-ancestor origin/${branch} origin/main`, { cwd: repoPath, stdio: 'pipe' });
+        // If we get here, branch is fully merged
+        execSync(`git push origin --delete "${branch}"`, { cwd: repoPath, stdio: 'pipe' });
+        execSync(`git branch -d "${branch}" 2>/dev/null || true`, { cwd: repoPath, stdio: 'pipe', shell: true });
+        staleCleaned++;
+      } catch {}
+    }
+    if (staleCleaned > 0) {
+      console.log(`  ✓ Cleaned ${staleCleaned} stale branch(es)`);
+    }
+  } catch (e) {
+    console.log(`  ! Branch prune skipped: ${e.message}`);
   }
 
   console.log('');

package/mcp-server.mjs

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+// wip-release/mcp-server.mjs
+// MCP server exposing release pipeline as tools.
+// Wraps core.mjs. Registered via .mcp.json.
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import {
+  release, detectCurrentVersion, bumpSemver, buildReleaseNotes,
+} from './core.mjs';
+
+const server = new Server(
+  { name: 'wip-release', version: '1.3.0' },
+  { capabilities: { tools: {} } }
+);
+
+// ── Tool Definitions ──
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: 'release',
+      description: 'Run the full release pipeline. Bumps version, updates changelog + SKILL.md, commits, tags, publishes to npm + GitHub. Must be run from repo root or provide repoPath.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          repoPath: { type: 'string', description: 'Absolute path to the repo. Defaults to cwd.' },
+          level: { type: 'string', enum: ['patch', 'minor', 'major'], description: 'Semver bump level' },
+          notes: { type: 'string', description: 'Changelog entry and release notes summary' },
+          dryRun: { type: 'boolean', description: 'Preview only, no changes', default: false },
+          noPublish: { type: 'boolean', description: 'Bump + tag only, skip npm/GitHub publish', default: false },
+          skipProductCheck: { type: 'boolean', description: 'Skip product doc freshness check', default: false },
+        },
+        required: ['level', 'notes'],
+      },
+    },
+    {
+      name: 'release_status',
+      description: 'Check current version and what the next version would be for a given bump level.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          repoPath: { type: 'string', description: 'Absolute path to the repo. Defaults to cwd.' },
+          level: { type: 'string', enum: ['patch', 'minor', 'major'], description: 'Semver bump level to preview' },
+        },
+        required: ['level'],
+      },
+    },
+  ],
+}));
+
+// ── Tool Handlers ──
+
+server.setRequestHandler(CallToolRequestSchema, async (req) => {
+  const { name, arguments: args } = req.params;
+
+  if (name === 'release') {
+    try {
+      const result = await release({
+        repoPath: args.repoPath || process.cwd(),
+        level: args.level,
+        notes: args.notes,
+        dryRun: args.dryRun || false,
+        notesSource: 'flag', // MCP always passes notes directly
+        noPublish: args.noPublish || false,
+        skipProductCheck: args.skipProductCheck || false,
+      });
+      return {
+        content: [{
+          type: 'text',
+          text: `Release complete: ${result.currentVersion} -> ${result.newVersion}${result.dryRun ? ' (dry run)' : ''}`,
+        }],
+      };
+    } catch (err) {
+      return {
+        content: [{ type: 'text', text: `Release failed: ${err.message}` }],
+        isError: true,
+      };
+    }
+  }
+
+  if (name === 'release_status') {
+    try {
+      const repoPath = args.repoPath || process.cwd();
+      const current = detectCurrentVersion(repoPath);
+      const next = bumpSemver(current, args.level);
+      return {
+        content: [{
+          type: 'text',
+          text: `Current: ${current}\nNext (${args.level}): ${next}`,
+        }],
+      };
+    } catch (err) {
+      return {
+        content: [{ type: 'text', text: `Status check failed: ${err.message}` }],
+        isError: true,
+      };
+    }
+  }
+
+  return {
+    content: [{ type: 'text', text: `Unknown tool: ${name}` }],
+    isError: true,
+  };
+});
+
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wipcomputer/wip-release",
-  "version": "1.2.4",
+  "version": "1.9.7",
   "type": "module",
   "description": "One-command release pipeline. Bumps version, updates changelog + SKILL.md, publishes to npm + GitHub.",
   "main": "core.mjs",
@@ -12,7 +12,7 @@
     "./cli": "./cli.js"
   },
   "scripts": {
-    "test": "node cli.mjs --help"
+    "test": "node cli.js --help"
   },
   "keywords": [
     "release",
@@ -29,5 +29,8 @@
     "type": "git",
     "url": "git+https://github.com/wipcomputer/wip-release.git"
   },
-  "homepage": "https://github.com/wipcomputer/wip-release"
+  "homepage": "https://github.com/wipcomputer/wip-ai-devops-toolbox",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  }
 }