@a-company/paradigm 3.1.4 → 3.1.6

package/dist/check-UZY647TB.js

@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+import "./chunk-MO4EEYFW.js";
+
+// src/commands/plugin/check.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { exec } from "child_process";
+import chalk from "chalk";
+function execAsync(cmd, options = {}) {
+  return new Promise((resolve, reject) => {
+    exec(cmd, { timeout: options.timeout || 5e3, cwd: options.cwd }, (err, stdout) => {
+      if (err) return reject(err);
+      resolve(stdout.trim());
+    });
+  });
+}
+function readJsonSafe(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return null;
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function discoverPlugins() {
+  const plugins = [];
+  const claudePluginsDir = path.join(os.homedir(), ".claude", "plugins");
+  const marketplacesDir = path.join(claudePluginsDir, "marketplaces");
+  const cacheDir = path.join(claudePluginsDir, "cache");
+  if (!fs.existsSync(marketplacesDir)) return plugins;
+  let marketplaceRepos;
+  try {
+    marketplaceRepos = fs.readdirSync(marketplacesDir).filter((d) => {
+      const fullPath = path.join(marketplacesDir, d);
+      return fs.statSync(fullPath).isDirectory() && fs.existsSync(path.join(fullPath, ".git"));
+    });
+  } catch {
+    return plugins;
+  }
+  for (const repoDir of marketplaceRepos) {
+    const marketplacePath = path.join(marketplacesDir, repoDir);
+    const pluginsSubdir = path.join(marketplacePath, "plugins");
+    if (!fs.existsSync(pluginsSubdir)) continue;
+    let pluginDirs;
+    try {
+      pluginDirs = fs.readdirSync(pluginsSubdir).filter(
+        (d) => fs.statSync(path.join(pluginsSubdir, d)).isDirectory()
+      );
+    } catch {
+      continue;
+    }
+    for (const pluginName of pluginDirs) {
+      const pluginJsonPath = path.join(pluginsSubdir, pluginName, ".claude-plugin", "plugin.json");
+      const pluginJson = readJsonSafe(pluginJsonPath);
+      if (!pluginJson) continue;
+      const localVersion = pluginJson.version || "unknown";
+      const pluginCacheDir = path.join(cacheDir, repoDir, pluginName);
+      let installedVersion = "unknown";
+      if (fs.existsSync(pluginCacheDir)) {
+        try {
+          const versions = fs.readdirSync(pluginCacheDir).filter((d) => fs.statSync(path.join(pluginCacheDir, d)).isDirectory()).sort().reverse();
+          if (versions.length > 0) installedVersion = versions[0];
+        } catch {
+        }
+      }
+      let repo = repoDir;
+      try {
+        const gitConfig = fs.readFileSync(path.join(marketplacePath, ".git", "config"), "utf8");
+        const match = gitConfig.match(/github\.com[:/]([^/]+\/[^/\s.]+)/);
+        if (match) repo = match[1].replace(/\.git$/, "");
+      } catch {
+      }
+      plugins.push({ repo, plugin: pluginName, installedVersion, marketplacePath, localVersion });
+    }
+  }
+  return plugins;
+}
+async function checkPlugin(plugin) {
+  let remoteSha = null;
+  let localSha = "unknown";
+  try {
+    localSha = await execAsync("git rev-parse HEAD", { cwd: plugin.marketplacePath });
+  } catch {
+  }
+  try {
+    const output = await execAsync("git ls-remote origin HEAD", {
+      cwd: plugin.marketplacePath,
+      timeout: 5e3
+    });
+    const match = output.match(/^([a-f0-9]+)/);
+    if (match) remoteSha = match[1];
+  } catch {
+  }
+  const hasRemoteUpdate = remoteSha !== null && remoteSha !== localSha;
+  const hasCacheStale = plugin.localVersion !== plugin.installedVersion && plugin.installedVersion !== "unknown";
+  return {
+    repo: plugin.repo,
+    plugin: plugin.plugin,
+    installedVersion: plugin.installedVersion,
+    localVersion: plugin.localVersion,
+    remoteSha,
+    localSha,
+    marketplacePath: plugin.marketplacePath,
+    hasRemoteUpdate,
+    hasCacheStale
+  };
+}
+async function pluginCheckCommand(options = {}) {
+  console.log(chalk.blue("\nPlugin Update Check\n"));
+  const plugins = discoverPlugins();
+  if (plugins.length === 0) {
+    console.log(chalk.gray("No Claude Code plugins found in ~/.claude/plugins/marketplaces/"));
+    console.log(chalk.gray("Install plugins with: /plugin marketplace add <owner>/<repo>\n"));
+    return;
+  }
+  console.log(chalk.gray(`Checking ${plugins.length} plugin(s)...
+`));
+  const results = await Promise.all(plugins.map((p) => checkPlugin(p)));
+  const updatable = results.filter((r) => r.hasRemoteUpdate || r.hasCacheStale);
+  for (const r of results) {
+    const status = r.hasRemoteUpdate ? chalk.yellow("update available") : r.hasCacheStale ? chalk.cyan("restart needed") : chalk.green("up to date");
+    const version = r.installedVersion !== "unknown" ? `${r.installedVersion} \u2192 ${r.localVersion}` : r.localVersion;
+    console.log(`  ${chalk.bold(r.plugin)} ${chalk.gray(`(${r.repo})`)}`);
+    console.log(`    Version: ${version}  Status: ${status}`);
+    if (r.hasRemoteUpdate) {
+      console.log(chalk.gray(`    Local:  ${r.localSha?.slice(0, 8) || "?"}`));
+      console.log(chalk.gray(`    Remote: ${r.remoteSha?.slice(0, 8) || "?"}`));
+    }
+    if (r.remoteSha === null) {
+      console.log(chalk.gray("    (remote check skipped \u2014 network unavailable)"));
+    }
+    console.log();
+  }
+  if (updatable.length === 0) {
+    console.log(chalk.green("All plugins are up to date.\n"));
+    return;
+  }
+  const remoteUpdates = updatable.filter((r) => r.hasRemoteUpdate);
+  if (options.update && remoteUpdates.length > 0) {
+    console.log(chalk.blue("Pulling updates...\n"));
+    for (const r of remoteUpdates) {
+      process.stdout.write(`  ${r.plugin}: `);
+      try {
+        await execAsync("git pull origin main", {
+          cwd: r.marketplacePath,
+          timeout: 15e3
+        });
+        console.log(chalk.green("updated"));
+      } catch (err) {
+        console.log(chalk.red(`failed \u2014 ${err instanceof Error ? err.message : "unknown error"}`));
+      }
+    }
+    console.log(chalk.yellow("\nRestart your Claude Code session to apply updates.\n"));
+  } else if (remoteUpdates.length > 0) {
+    console.log(chalk.yellow("To pull updates, run:"));
+    for (const r of remoteUpdates) {
+      console.log(chalk.gray(`  git -C ${r.marketplacePath} pull origin main`));
+    }
+    console.log(chalk.gray("\nOr run: paradigm plugin check --update"));
+    console.log(chalk.yellow("\nAfter updating, restart your Claude Code session.\n"));
+  } else {
+    console.log(chalk.yellow("Restart your Claude Code session to apply cached updates.\n"));
+  }
+}
+export {
+  pluginCheckCommand
+};

package/dist/chunk-4G54C4VM.js

@@ -0,0 +1,241 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../paradigm-mcp/src/utils/plugin-update-checker.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { exec } from "child_process";
+var CLAUDE_PLUGINS_DIR = path.join(os.homedir(), ".claude", "plugins");
+var CHECK_STATE_PATH = path.join(os.homedir(), ".paradigm", "plugin-update-check.json");
+var THROTTLE_HOURS = 6;
+function execAsync(cmd, options = {}) {
+  return new Promise((resolve, reject) => {
+    exec(cmd, { timeout: options.timeout || 3e3, cwd: options.cwd }, (err, stdout) => {
+      if (err) return reject(err);
+      resolve(stdout.trim());
+    });
+  });
+}
+function readJsonSafe(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return null;
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function loadCheckState() {
+  return readJsonSafe(CHECK_STATE_PATH);
+}
+function saveCheckState(state) {
+  const dir = path.dirname(CHECK_STATE_PATH);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(CHECK_STATE_PATH, JSON.stringify(state, null, 2));
+}
+function isThrottled() {
+  const state = loadCheckState();
+  if (!state) return false;
+  const elapsed = Date.now() - new Date(state.lastCheck).getTime();
+  return elapsed < THROTTLE_HOURS * 3600 * 1e3;
+}
+function discoverPlugins() {
+  const plugins = [];
+  const marketplacesDir = path.join(CLAUDE_PLUGINS_DIR, "marketplaces");
+  const cacheDir = path.join(CLAUDE_PLUGINS_DIR, "cache");
+  if (!fs.existsSync(marketplacesDir)) return plugins;
+  let marketplaceRepos;
+  try {
+    marketplaceRepos = fs.readdirSync(marketplacesDir).filter((d) => {
+      const fullPath = path.join(marketplacesDir, d);
+      return fs.statSync(fullPath).isDirectory() && fs.existsSync(path.join(fullPath, ".git"));
+    });
+  } catch {
+    return plugins;
+  }
+  for (const repoDir of marketplaceRepos) {
+    const marketplacePath = path.join(marketplacesDir, repoDir);
+    const pluginsSubdir = path.join(marketplacePath, "plugins");
+    if (!fs.existsSync(pluginsSubdir)) continue;
+    let pluginDirs;
+    try {
+      pluginDirs = fs.readdirSync(pluginsSubdir).filter(
+        (d) => fs.statSync(path.join(pluginsSubdir, d)).isDirectory()
+      );
+    } catch {
+      continue;
+    }
+    for (const pluginName of pluginDirs) {
+      const pluginJsonPath = path.join(pluginsSubdir, pluginName, ".claude-plugin", "plugin.json");
+      const pluginJson = readJsonSafe(pluginJsonPath);
+      if (!pluginJson) continue;
+      const localVersion = pluginJson.version || "unknown";
+      const pluginCacheDir = path.join(cacheDir, repoDir, pluginName);
+      let installedVersion = "unknown";
+      let installedSha = "unknown";
+      if (fs.existsSync(pluginCacheDir)) {
+        try {
+          const versions = fs.readdirSync(pluginCacheDir).filter((d) => fs.statSync(path.join(pluginCacheDir, d)).isDirectory()).sort().reverse();
+          if (versions.length > 0) {
+            installedVersion = versions[0];
+            const cachedPluginJson = readJsonSafe(
+              path.join(pluginCacheDir, versions[0], ".claude-plugin", "plugin.json")
+            );
+            if (cachedPluginJson?.sha) {
+              installedSha = cachedPluginJson.sha;
+            }
+          }
+        } catch {
+        }
+      }
+      let repo = repoDir;
+      try {
+        const remoteUrl = fs.readFileSync(
+          path.join(marketplacePath, ".git", "config"),
+          "utf8"
+        );
+        const match = remoteUrl.match(/github\.com[:/]([^/]+\/[^/\s.]+)/);
+        if (match) {
+          repo = match[1].replace(/\.git$/, "");
+        }
+      } catch {
+      }
+      plugins.push({
+        repo,
+        plugin: pluginName,
+        installedVersion,
+        installedSha,
+        marketplacePath,
+        localVersion
+      });
+    }
+  }
+  return plugins;
+}
+async function checkPlugin(plugin) {
+  let remoteSha = null;
+  let localSha = plugin.installedSha;
+  try {
+    localSha = await execAsync("git rev-parse HEAD", { cwd: plugin.marketplacePath });
+  } catch {
+  }
+  try {
+    const output = await execAsync("git ls-remote origin HEAD", {
+      cwd: plugin.marketplacePath,
+      timeout: 3e3
+    });
+    const match = output.match(/^([a-f0-9]+)/);
+    if (match) {
+      remoteSha = match[1];
+    }
+  } catch {
+  }
+  const hasRemoteUpdate = remoteSha !== null && remoteSha !== localSha;
+  const hasCacheStale = plugin.localVersion !== plugin.installedVersion && plugin.installedVersion !== "unknown";
+  return {
+    repo: plugin.repo,
+    plugin: plugin.plugin,
+    installedVersion: plugin.installedVersion,
+    installedSha: localSha,
+    localVersion: plugin.localVersion,
+    remoteSha,
+    marketplacePath: plugin.marketplacePath,
+    hasRemoteUpdate,
+    hasCacheStale
+  };
+}
+function getPluginUpdateNotice() {
+  const state = loadCheckState();
+  if (!state?.results) return null;
+  const updatable = state.results.filter((r) => r.hasRemoteUpdate || r.hasCacheStale);
+  if (updatable.length === 0) return null;
+  const lines = [];
+  lines.push("--- PLUGIN UPDATES AVAILABLE ---");
+  lines.push("Updates available for installed Claude Code plugins:");
+  const pullCmds = [];
+  for (const r of updatable) {
+    if (r.hasRemoteUpdate) {
+      const versionInfo = r.installedVersion !== "unknown" ? `${r.installedVersion} \u2192 ${r.localVersion}` : "newer commits available";
+      lines.push(`  - ${r.plugin} (${r.repo}): ${versionInfo}`);
+      pullCmds.push(`git -C ${r.marketplacePath} pull origin main`);
+    } else if (r.hasCacheStale) {
+      lines.push(`  - ${r.plugin} (${r.repo}): ${r.installedVersion} \u2192 ${r.localVersion} (restart needed)`);
+    }
+  }
+  if (pullCmds.length > 0) {
+    lines.push("");
+    lines.push("Tell the user about these updates and suggest running:");
+    lines.push(`  ${pullCmds.join(" && \\\n  ")}`);
+    lines.push("");
+    lines.push("After updating, the user should restart their Claude Code session.");
+  } else {
+    lines.push("");
+    lines.push("Restart the session to apply cached updates.");
+  }
+  lines.push("---");
+  return lines.join("\n");
+}
+function schedulePluginUpdateCheck() {
+  if (isThrottled()) return;
+  (async () => {
+    try {
+      const results = await runPluginUpdateCheck();
+      saveCheckState({
+        lastCheck: (/* @__PURE__ */ new Date()).toISOString(),
+        results
+      });
+    } catch {
+    }
+  })();
+}
+async function runPluginUpdateCheck() {
+  const plugins = discoverPlugins();
+  if (plugins.length === 0) return [];
+  const results = await Promise.all(plugins.map((p) => checkPlugin(p)));
+  saveCheckState({
+    lastCheck: (/* @__PURE__ */ new Date()).toISOString(),
+    results
+  });
+  return results;
+}
+
+export {
+  __require,
+  __commonJS,
+  __toESM,
+  getPluginUpdateNotice,
+  schedulePluginUpdateCheck,
+  runPluginUpdateCheck
+};

package/dist/{chunk-6HZ7PZGG.js → chunk-HXY6AY52.js}

@@ -3,6 +3,7 @@
 // src/commands/hooks/index.ts
 import * as fs from "fs";
 import * as path from "path";
+import * as os from "os";
 import chalk from "chalk";
 
 // src/commands/hooks/generated-hooks.ts
@@ -247,6 +248,8 @@ fi
 # --- Check 7: Lore entry expected for significant sessions ---
 if [ "$SOURCE_COUNT" -ge 3 ] && [ -d ".paradigm/lore" ]; then
   LORE_RECORDED=false
+
+  # Check git diff first (covers staged/committed lore)
   for file in $MODIFIED; do
     case "$file" in
       .paradigm/lore/entries/*.yaml|.paradigm/lore/entries/*/*.yaml)
@@ -256,6 +259,17 @@ if [ "$SOURCE_COUNT" -ge 3 ] && [ -d ".paradigm/lore" ]; then
     esac
   done
 
+  # Also check for recent lore on disk (covers MCP-written entries not yet staged)
+  if [ "$LORE_RECORDED" = false ]; then
+    TODAY=$(date -u +"%Y-%m-%d")
+    if [ -d ".paradigm/lore/entries/$TODAY" ]; then
+      ENTRY_COUNT=$(find ".paradigm/lore/entries/$TODAY" -name "*.yaml" 2>/dev/null | head -1)
+      if [ -n "$ENTRY_COUNT" ]; then
+        LORE_RECORDED=true
+      fi
+    fi
+  fi
+
   if [ "$LORE_RECORDED" = false ]; then
     VIOLATIONS="$VIOLATIONS
   - You modified $SOURCE_COUNT source files but recorded no lore entry.
@@ -702,6 +716,8 @@ fi
 # --- Check 7: Lore entry expected for significant sessions ---
 if [ "$SOURCE_COUNT" -ge 3 ] && [ -d ".paradigm/lore" ]; then
   LORE_RECORDED=false
+
+  # Check git diff first (covers staged/committed lore)
   for file in $MODIFIED; do
     case "$file" in
       .paradigm/lore/entries/*.yaml|.paradigm/lore/entries/*/*.yaml)
@@ -711,6 +727,17 @@ if [ "$SOURCE_COUNT" -ge 3 ] && [ -d ".paradigm/lore" ]; then
     esac
   done
 
+  # Also check for recent lore on disk (covers MCP-written entries not yet staged)
+  if [ "$LORE_RECORDED" = false ]; then
+    TODAY=$(date -u +"%Y-%m-%d")
+    if [ -d ".paradigm/lore/entries/$TODAY" ]; then
+      ENTRY_COUNT=$(find ".paradigm/lore/entries/$TODAY" -name "*.yaml" 2>/dev/null | head -1)
+      if [ -n "$ENTRY_COUNT" ]; then
+        LORE_RECORDED=true
+      fi
+    fi
+  fi
+
   if [ "$LORE_RECORDED" = false ]; then
     VIOLATIONS="$VIOLATIONS
   - You modified $SOURCE_COUNT source files but recorded no lore entry.
@@ -918,6 +945,80 @@ exit 0
 `;
 
 // src/commands/hooks/index.ts
+function isParadigmPluginActive() {
+  try {
+    const globalSettingsPath = path.join(os.homedir(), ".claude", "settings.json");
+    if (!fs.existsSync(globalSettingsPath)) return { active: false };
+    const settings = JSON.parse(fs.readFileSync(globalSettingsPath, "utf8"));
+    const enabled = settings.enabledPlugins?.["paradigm@a-paradigm"];
+    if (!enabled) return { active: false };
+    const cacheBase = path.join(os.homedir(), ".claude", "plugins", "cache", "a-paradigm", "paradigm");
+    if (!fs.existsSync(cacheBase)) return { active: false };
+    const versions = fs.readdirSync(cacheBase).filter((d) => fs.statSync(path.join(cacheBase, d)).isDirectory()).sort().reverse();
+    if (versions.length === 0) return { active: false };
+    const latestCache = path.join(cacheBase, versions[0]);
+    const hooksJson = path.join(latestCache, "hooks", "hooks.json");
+    if (!fs.existsSync(hooksJson)) return { active: false };
+    return { active: true, cacheVersion: versions[0] };
+  } catch {
+    return { active: false };
+  }
+}
+function cleanupProjectClaudeCodeHooks(rootDir) {
+  const removed = [];
+  const claudeHooksDir = path.join(rootDir, ".claude", "hooks");
+  if (fs.existsSync(claudeHooksDir)) {
+    for (const hookName of ["paradigm-stop.sh", "paradigm-precommit.sh", "paradigm-postwrite.sh"]) {
+      const hookPath = path.join(claudeHooksDir, hookName);
+      if (fs.existsSync(hookPath)) {
+        fs.unlinkSync(hookPath);
+        removed.push(hookName);
+      }
+    }
+    try {
+      const remaining = fs.readdirSync(claudeHooksDir);
+      if (remaining.length === 0) {
+        fs.rmdirSync(claudeHooksDir);
+      }
+    } catch {
+    }
+  }
+  const settingsPath = path.join(rootDir, ".claude", "settings.json");
+  if (fs.existsSync(settingsPath)) {
+    try {
+      const settings = JSON.parse(fs.readFileSync(settingsPath, "utf8"));
+      const hooks = settings.hooks;
+      if (hooks) {
+        let modified = false;
+        for (const [key, arr] of Object.entries(hooks)) {
+          if (!Array.isArray(arr)) continue;
+          const filtered = arr.filter(
+            (h) => !JSON.stringify(h).includes("paradigm-")
+          );
+          if (filtered.length !== arr.length) {
+            modified = true;
+            if (filtered.length === 0) {
+              delete hooks[key];
+            } else {
+              hooks[key] = filtered;
+            }
+          }
+        }
+        if (modified) {
+          if (Object.keys(hooks).length === 0) {
+            delete settings.hooks;
+          } else {
+            settings.hooks = hooks;
+          }
+          fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
+          removed.push("settings.json hooks");
+        }
+      }
+    } catch {
+    }
+  }
+  return { cleaned: removed.length > 0, removed };
+}
 var POST_COMMIT_HOOK = `#!/bin/sh
 # Paradigm post-commit hook - captures history from commits
 # Installed by: paradigm hooks install
@@ -1073,6 +1174,18 @@ async function hooksInstallCommand(options = {}) {
   }
 }
 async function installClaudeCodeHooks(rootDir, force) {
+  const plugin = isParadigmPluginActive();
+  if (plugin.active) {
+    console.log(chalk.cyan(`  Paradigm plugin v${plugin.cacheVersion} is active \u2014 hooks are managed by the plugin.`));
+    const { cleaned, removed } = cleanupProjectClaudeCodeHooks(rootDir);
+    if (cleaned) {
+      console.log(chalk.green(`  Cleaned up stale project hooks: ${removed.join(", ")}`));
+    } else {
+      console.log(chalk.gray("  No stale project hooks to clean up."));
+    }
+    console.log(chalk.gray("  Plugin hooks auto-update with each session \u2014 no manual install needed."));
+    return;
+  }
   const claudeHooksDir = path.join(rootDir, ".claude", "hooks");
   fs.mkdirSync(claudeHooksDir, { recursive: true });
   const installed = [];
@@ -1327,32 +1440,60 @@ async function hooksStatusCommand() {
     console.log(chalk.gray("\n  Not a git repository (git hooks N/A)\n"));
   }
   console.log(chalk.magenta("  Claude Code Hooks Status\n"));
-  const claudeHooksDir = path.join(rootDir, ".claude", "hooks");
-  const claudeHooks = ["paradigm-stop.sh", "paradigm-precommit.sh", "paradigm-postwrite.sh"];
-  for (const hookName of claudeHooks) {
-    const hookPath = path.join(claudeHooksDir, hookName);
-    if (fs.existsSync(hookPath)) {
-      console.log(chalk.green(`  ${hookName}: installed`));
-    } else {
-      console.log(chalk.gray(`  ${hookName}: not installed`));
+  const plugin = isParadigmPluginActive();
+  if (plugin.active) {
+    console.log(chalk.cyan(`  Plugin: paradigm v${plugin.cacheVersion} (active)`));
+    console.log(chalk.green("  Hooks are managed by the plugin \u2014 auto-updates with each session."));
+    const claudeHooksDir = path.join(rootDir, ".claude", "hooks");
+    const staleHooks = [];
+    for (const hookName of ["paradigm-stop.sh", "paradigm-precommit.sh", "paradigm-postwrite.sh"]) {
+      if (fs.existsSync(path.join(claudeHooksDir, hookName))) {
+        staleHooks.push(hookName);
+      }
     }
-  }
-  const settingsPath = path.join(rootDir, ".claude", "settings.json");
-  if (fs.existsSync(settingsPath)) {
-    try {
-      const settings = JSON.parse(fs.readFileSync(settingsPath, "utf8"));
-      const hooks = settings.hooks || {};
-      const hasStop = JSON.stringify(hooks.Stop || []).includes("paradigm-stop.sh");
-      const hasPrecommit = JSON.stringify(hooks.PreToolUse || []).includes("paradigm-precommit.sh");
-      const hasPostwrite = JSON.stringify(hooks.PostToolUse || []).includes("paradigm-postwrite.sh");
-      console.log(chalk.gray(`  settings.json Stop hook: ${hasStop ? "configured" : "missing"}`));
-      console.log(chalk.gray(`  settings.json PreToolUse hook: ${hasPrecommit ? "configured" : "missing"}`));
-      console.log(chalk.gray(`  settings.json PostToolUse hook: ${hasPostwrite ? "configured" : "missing"}`));
-    } catch {
-      console.log(chalk.yellow("  settings.json: parse error"));
+    const settingsPath = path.join(rootDir, ".claude", "settings.json");
+    let hasProjectHookEntries = false;
+    if (fs.existsSync(settingsPath)) {
+      try {
+        const settings = JSON.parse(fs.readFileSync(settingsPath, "utf8"));
+        hasProjectHookEntries = JSON.stringify(settings.hooks || {}).includes("paradigm-");
+      } catch {
+      }
+    }
+    if (staleHooks.length > 0 || hasProjectHookEntries) {
+      console.log(chalk.yellow(`  WARNING: Stale project hooks detected (${staleHooks.join(", ")}${hasProjectHookEntries ? ", settings.json entries" : ""})`));
+      console.log(chalk.yellow("  These shadow the plugin hooks and may run outdated logic."));
+      console.log(chalk.gray("  Run `paradigm hooks install --claude-code` to clean them up."));
     }
   } else {
-    console.log(chalk.gray("  settings.json: not found"));
+    console.log(chalk.gray("  Plugin: not active (using project-level hooks)"));
+    const claudeHooksDir = path.join(rootDir, ".claude", "hooks");
+    const claudeHooks = ["paradigm-stop.sh", "paradigm-precommit.sh", "paradigm-postwrite.sh"];
+    for (const hookName of claudeHooks) {
+      const hookPath = path.join(claudeHooksDir, hookName);
+      if (fs.existsSync(hookPath)) {
+        console.log(chalk.green(`  ${hookName}: installed`));
+      } else {
+        console.log(chalk.gray(`  ${hookName}: not installed`));
+      }
+    }
+    const settingsPath = path.join(rootDir, ".claude", "settings.json");
+    if (fs.existsSync(settingsPath)) {
+      try {
+        const settings = JSON.parse(fs.readFileSync(settingsPath, "utf8"));
+        const hooks = settings.hooks || {};
+        const hasStop = JSON.stringify(hooks.Stop || []).includes("paradigm-stop.sh");
+        const hasPrecommit = JSON.stringify(hooks.PreToolUse || []).includes("paradigm-precommit.sh");
+        const hasPostwrite = JSON.stringify(hooks.PostToolUse || []).includes("paradigm-postwrite.sh");
+        console.log(chalk.gray(`  settings.json Stop hook: ${hasStop ? "configured" : "missing"}`));
+        console.log(chalk.gray(`  settings.json PreToolUse hook: ${hasPrecommit ? "configured" : "missing"}`));
+        console.log(chalk.gray(`  settings.json PostToolUse hook: ${hasPostwrite ? "configured" : "missing"}`));
+      } catch {
+        console.log(chalk.yellow("  settings.json: parse error"));
+      }
+    } else {
+      console.log(chalk.gray("  settings.json: not found"));
+    }
   }
   console.log(chalk.magenta("\n  Cursor Hooks Status\n"));
   const cursorHooksDir = path.join(rootDir, ".cursor", "hooks");

package/dist/{hooks-QGUF77MB.js → hooks-RLJFGKPF.js}

@@ -3,7 +3,7 @@ import {
   hooksInstallCommand,
   hooksStatusCommand,
   hooksUninstallCommand
-} from "./chunk-6HZ7PZGG.js";
+} from "./chunk-HXY6AY52.js";
 import "./chunk-MO4EEYFW.js";
 export {
   hooksInstallCommand,

package/dist/index.js

@@ -109,7 +109,7 @@ ${chalk2.magenta("\u2569  ")}${chalk2.cyan("\u2534 \u2534\u2534\u2514\u2500\u253
 program.name("paradigm").description("Unified developer tools ecosystem").version(VERSION).addHelpText("before", banner);
 program.command("init").description("Initialize Paradigm in the current project").option("-f, --force", "Overwrite existing files").option("--name <name>", "Project name").option("--ide <ide>", "Target IDE: cursor, copilot, windsurf, claude").option("--migrate", "Output migration prompt for existing IDE files").option("--quick", "Non-interactive mode with smart defaults").option("--dry-run", "Show what would be created without creating").action(initCommand);
 program.command("shift").description("Full project setup in one command (init + team init + scan + sync all IDEs + doctor)").option("-f, --force", "Reinitialize even if already setup").option("-q, --quick", "Skip slow operations (scan)").option("--verify", "Run health checks after setup").option("--ide <ide>", "Target specific IDE instead of all").option("--configure-models", "Force model configuration prompts for team agents").action(async (options) => {
-  const { shiftCommand } = await import("./shift-OCNF4575.js");
+  const { shiftCommand } = await import("./shift-YELZUPYG.js");
   await shiftCommand(options);
 });
 program.command("setup [path]").description("Interactive setup wizard for Paradigm").option("-y, --yes", "Accept all defaults (non-interactive)").option("-f, --force", "Overwrite existing .paradigm config").action(async (path2, options) => {
@@ -277,6 +277,15 @@ teamCmd.action(async () => {
   const { teamStatusCommand } = await import("./team-NWP2KJAB.js");
   await teamStatusCommand(void 0, {});
 });
+var pluginCmd = program.command("plugin").description("Plugin management commands");
+pluginCmd.command("check").description("Check for updates to installed Claude Code plugins").option("-u, --update", "Pull latest changes for all stale marketplace clones").action(async (options) => {
+  const { pluginCheckCommand } = await import("./check-UZY647TB.js");
+  await pluginCheckCommand(options);
+});
+pluginCmd.action(async () => {
+  const { pluginCheckCommand } = await import("./check-UZY647TB.js");
+  await pluginCheckCommand({});
+});
 program.command("doctor").description("Health check - validate Paradigm setup").action(async () => {
   const { doctorCommand } = await import("./doctor-JBIV5PMN.js");
   await doctorCommand();
@@ -470,19 +479,19 @@ historyCmd.option("--json", "Output as JSON").action(async (options) => {
 });
 var hooksCmd = program.command("hooks").description("Git hooks for automatic history capture");
 hooksCmd.command("install").description("Install git hooks, Claude Code hooks, and Cursor hooks").option("-f, --force", "Overwrite existing hooks").option("--post-commit", "Only install post-commit hook").option("--pre-push", "Only install pre-push hook").option("--claude-code", "Only install Claude Code hooks (stop + pre-commit)").option("--cursor", "Only install Cursor hooks (.cursor/hooks.json)").action(async (options) => {
-  const { hooksInstallCommand } = await import("./hooks-QGUF77MB.js");
+  const { hooksInstallCommand } = await import("./hooks-RLJFGKPF.js");
   await hooksInstallCommand(options);
 });
 hooksCmd.command("uninstall").description("Remove paradigm hooks (git hooks, or --cursor for Cursor hooks)").option("--cursor", "Remove Cursor hooks instead of git hooks").action(async (options) => {
-  const { hooksUninstallCommand } = await import("./hooks-QGUF77MB.js");
+  const { hooksUninstallCommand } = await import("./hooks-RLJFGKPF.js");
   await hooksUninstallCommand(options);
 });
 hooksCmd.command("status").description("Check git hooks status").action(async () => {
-  const { hooksStatusCommand } = await import("./hooks-QGUF77MB.js");
+  const { hooksStatusCommand } = await import("./hooks-RLJFGKPF.js");
   await hooksStatusCommand();
 });
 hooksCmd.action(async () => {
-  const { hooksStatusCommand } = await import("./hooks-QGUF77MB.js");
+  const { hooksStatusCommand } = await import("./hooks-RLJFGKPF.js");
   await hooksStatusCommand();
 });
 var triageCmd = program.command("triage").description("Semantic error triage - incident management and pattern matching");

package/dist/mcp.js

@@ -1,35 +1,11 @@
 #!/usr/bin/env node
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var __commonJS = (cb, mod) => function __require2() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
+import {
+  __commonJS,
+  __require,
+  __toESM,
+  getPluginUpdateNotice,
+  schedulePluginUpdateCheck
+} from "./chunk-4G54C4VM.js";
 
 // ../../node_modules/sql.js/dist/sql-wasm.js
 var require_sql_wasm = __commonJS({
@@ -16354,7 +16330,20 @@ function registerTools(server, getContext2, reloadContext2) {
           // Lore tools
           ...getLoreToolsList(),
           // Habits tools
-          ...getHabitsToolsList()
+          ...getHabitsToolsList(),
+          // Plugin update check
+          {
+            name: "paradigm_plugin_check",
+            description: "Check for updates to installed Claude Code plugins. Reports which marketplace clones have newer remote commits and which cached versions are stale.",
+            inputSchema: {
+              type: "object",
+              properties: {}
+            },
+            annotations: {
+              readOnlyHint: true,
+              destructiveHint: false
+            }
+          }
         ]
       };
     }
@@ -16368,8 +16357,11 @@ function registerTools(server, getContext2, reloadContext2) {
       const tracker2 = getSessionTracker();
       tracker2.setRootDir(ctx.rootDir);
       let recoveryPreamble = null;
+      let updateNotice = null;
       if (!tracker2.hasRecoveredThisSession()) {
         recoveryPreamble = buildRecoveryPreamble(ctx.rootDir);
+        updateNotice = getPluginUpdateNotice();
+        schedulePluginUpdateCheck();
         tracker2.markRecovered();
       }
       const toolResult = await (async () => {
@@ -16802,6 +16794,37 @@ function registerTools(server, getContext2, reloadContext2) {
               }]
             };
           }
+          case "paradigm_plugin_check": {
+            const { runPluginUpdateCheck } = await import("./plugin-update-checker-EWT7YMDF.js");
+            const results = await runPluginUpdateCheck();
+            const updatable = results.filter((r) => r.hasRemoteUpdate || r.hasCacheStale);
+            if (updatable.length === 0) {
+              const msg = results.length === 0 ? "No Claude Code plugins found in ~/.claude/plugins/marketplaces/." : "All installed plugins are up to date.";
+              trackToolCall(msg.length, name);
+              return { content: [{ type: "text", text: msg }] };
+            }
+            const lines = ["Plugin updates available:\n"];
+            const pullCmds = [];
+            for (const r of updatable) {
+              if (r.hasRemoteUpdate) {
+                lines.push(`  ${r.plugin} (${r.repo}): remote has newer commits`);
+                pullCmds.push(`git -C ${r.marketplacePath} pull origin main`);
+              } else if (r.hasCacheStale) {
+                lines.push(`  ${r.plugin} (${r.repo}): ${r.installedVersion} \u2192 ${r.localVersion} (restart needed)`);
+              }
+            }
+            if (pullCmds.length > 0) {
+              lines.push(`
+Update command:
+  ${pullCmds.join(" && \\\n  ")}`);
+              lines.push("\nAfter running, restart the session to apply updates.");
+            } else {
+              lines.push("\nRestart the session to apply cached updates.");
+            }
+            const pluginText = lines.join("\n");
+            trackToolCall(pluginText.length, name);
+            return { content: [{ type: "text", text: pluginText }] };
+          }
           default: {
             if (name === "paradigm_navigate") {
               const result = await handleNavigateTool(name, args, ctx);
@@ -16934,10 +16957,11 @@ function registerTools(server, getContext2, reloadContext2) {
           }
         }
       })();
-      if (recoveryPreamble) {
+      if (recoveryPreamble || updateNotice) {
         const first = toolResult.content?.[0];
         if (first && typeof first === "object" && "text" in first && typeof first.text === "string") {
-          first.text = recoveryPreamble + "\n\n" + first.text;
+          const preamble = [updateNotice, recoveryPreamble].filter(Boolean).join("\n\n");
+          first.text = preamble + "\n\n" + first.text;
         }
       }
       return toolResult;

package/dist/plugin-update-checker-EWT7YMDF.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import {
+  getPluginUpdateNotice,
+  runPluginUpdateCheck,
+  schedulePluginUpdateCheck
+} from "./chunk-4G54C4VM.js";
+export {
+  getPluginUpdateNotice,
+  runPluginUpdateCheck,
+  schedulePluginUpdateCheck
+};

package/dist/{shift-OCNF4575.js → shift-YELZUPYG.js}

@@ -12,7 +12,7 @@ import {
 } from "./chunk-PMXRGPRQ.js";
 import {
   hooksInstallCommand
-} from "./chunk-6HZ7PZGG.js";
+} from "./chunk-HXY6AY52.js";
 import {
   indexCommand,
   initCommand

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a-company/paradigm",
-  "version": "3.1.4",
+  "version": "3.1.6",
   "description": "Unified CLI for Paradigm developer tools",
   "type": "module",
   "main": "./dist/index.js",