@a-company/paradigm 3.6.0 → 3.8.0

package/dist/assessment-loader-T4GPBHLB.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import {
+  closeArc,
+  createArc,
+  loadArc,
+  loadArcs,
+  loadEntries,
+  loadEntry,
+  rebuildAssessmentIndex,
+  recordEntry,
+  searchEntries
+} from "./chunk-DSXS42FY.js";
+import "./chunk-MO4EEYFW.js";
+export {
+  closeArc,
+  createArc,
+  loadArc,
+  loadArcs,
+  loadEntries,
+  loadEntry,
+  rebuildAssessmentIndex,
+  recordEntry,
+  searchEntries
+};

package/dist/{chunk-IRVA7NKV.js → chunk-BC6XKMUA.js}

@@ -548,6 +548,8 @@ ${purposeLines}
 function createMinimalStructure(paradigmDir, projectName) {
   fs.mkdirSync(path.join(paradigmDir, "specs"), { recursive: true });
   fs.mkdirSync(path.join(paradigmDir, "docs"), { recursive: true });
+  fs.mkdirSync(path.join(paradigmDir, "tasks"), { recursive: true });
+  fs.mkdirSync(path.join(paradigmDir, "assessments"), { recursive: true });
   const minimalConfig = `# Paradigm Configuration
 version: "1.0"
 project: "${projectName}"

package/dist/chunk-CSD7IHSN.js

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+
+// ../paradigm-mcp/src/utils/task-loader.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "js-yaml";
+var TASKS_ROOT = ".paradigm/tasks";
+var ENTRIES_DIR = "entries";
+var INDEX_FILE = "index.yaml";
+function generateTaskId(rootDir, dateStr) {
+  const datePath = path.join(rootDir, TASKS_ROOT, ENTRIES_DIR, dateStr);
+  if (!fs.existsSync(datePath)) {
+    return `T-${dateStr}-001`;
+  }
+  const existing = fs.readdirSync(datePath).filter((f) => f.startsWith("T-") && f.endsWith(".yaml")).map((f) => {
+    const match = f.match(/T-\d{4}-\d{2}-\d{2}-(\d+)\.yaml/);
+    return match ? parseInt(match[1], 10) : 0;
+  });
+  const next = existing.length > 0 ? Math.max(...existing) + 1 : 1;
+  return `T-${dateStr}-${String(next).padStart(3, "0")}`;
+}
+var PRIORITY_ORDER = { high: 0, medium: 1, low: 2 };
+function applyFilter(tasks, filter) {
+  let result = tasks;
+  if (filter.status && filter.status !== "all") {
+    result = result.filter((t) => t.status === filter.status);
+  }
+  if (filter.priority) {
+    result = result.filter((t) => t.priority === filter.priority);
+  }
+  if (filter.tag) {
+    result = result.filter((t) => t.tags.includes(filter.tag));
+  }
+  result.sort((a, b) => {
+    const priDiff = (PRIORITY_ORDER[a.priority] ?? 1) - (PRIORITY_ORDER[b.priority] ?? 1);
+    if (priDiff !== 0) return priDiff;
+    return new Date(b.created).getTime() - new Date(a.created).getTime();
+  });
+  if (filter.limit) {
+    result = result.slice(0, filter.limit);
+  }
+  return result;
+}
+async function loadTasks(rootDir, filter) {
+  const entriesPath = path.join(rootDir, TASKS_ROOT, ENTRIES_DIR);
+  if (!fs.existsSync(entriesPath)) return [];
+  const effectiveFilter = { status: "open", limit: 20, ...filter };
+  const tasks = [];
+  const dateDirs = fs.readdirSync(entriesPath).filter((d) => /^\d{4}-\d{2}-\d{2}$/.test(d)).sort().reverse();
+  for (const dateDir of dateDirs) {
+    const dirPath = path.join(entriesPath, dateDir);
+    const files = fs.readdirSync(dirPath).filter((f) => f.endsWith(".yaml")).sort();
+    for (const file of files) {
+      try {
+        const content = fs.readFileSync(path.join(dirPath, file), "utf8");
+        const task = yaml.load(content);
+        tasks.push(task);
+      } catch {
+      }
+    }
+  }
+  return applyFilter(tasks, effectiveFilter);
+}
+async function loadTask(rootDir, taskId) {
+  const dateMatch = taskId.match(/^T-(\d{4}-\d{2}-\d{2})-/);
+  if (dateMatch) {
+    const filePath = path.join(rootDir, TASKS_ROOT, ENTRIES_DIR, dateMatch[1], `${taskId}.yaml`);
+    if (fs.existsSync(filePath)) {
+      try {
+        return yaml.load(fs.readFileSync(filePath, "utf8"));
+      } catch {
+        return null;
+      }
+    }
+  }
+  const tasks = await loadTasks(rootDir, { status: "all", limit: 9999 });
+  return tasks.find((t) => t.id === taskId) || null;
+}
+async function createTask(rootDir, task) {
+  const now = /* @__PURE__ */ new Date();
+  const dateStr = now.toISOString().slice(0, 10);
+  const datePath = path.join(rootDir, TASKS_ROOT, ENTRIES_DIR, dateStr);
+  fs.mkdirSync(datePath, { recursive: true });
+  const id = generateTaskId(rootDir, dateStr);
+  const entry = {
+    id,
+    blurb: task.blurb,
+    priority: task.priority || "medium",
+    status: "open",
+    tags: task.tags || [],
+    created: now.toISOString(),
+    session_link: task.session_link,
+    related_lore: task.related_lore
+  };
+  fs.writeFileSync(path.join(datePath, `${id}.yaml`), yaml.dump(entry, { lineWidth: -1, noRefs: true }));
+  await rebuildTaskIndex(rootDir);
+  return id;
+}
+async function updateTask(rootDir, taskId, partial) {
+  const task = await loadTask(rootDir, taskId);
+  if (!task) return false;
+  const dateStr = task.created.slice(0, 10);
+  const taskPath = path.join(rootDir, TASKS_ROOT, ENTRIES_DIR, dateStr, `${taskId}.yaml`);
+  if (!fs.existsSync(taskPath)) return false;
+  const { id: _id, created: _created, ...safePartial } = partial;
+  const updated = { ...task, ...safePartial };
+  fs.writeFileSync(taskPath, yaml.dump(updated, { lineWidth: -1, noRefs: true }));
+  await rebuildTaskIndex(rootDir);
+  return true;
+}
+async function completeTask(rootDir, taskId) {
+  return updateTask(rootDir, taskId, { status: "done", completed: (/* @__PURE__ */ new Date()).toISOString() });
+}
+async function shelveTask(rootDir, taskId) {
+  return updateTask(rootDir, taskId, { status: "shelved", shelved: (/* @__PURE__ */ new Date()).toISOString() });
+}
+async function rebuildTaskIndex(rootDir) {
+  const entriesPath = path.join(rootDir, TASKS_ROOT, ENTRIES_DIR);
+  const tasksRootPath = path.join(rootDir, TASKS_ROOT);
+  let total = 0, open = 0, done = 0, shelved = 0;
+  if (fs.existsSync(entriesPath)) {
+    const dateDirs = fs.readdirSync(entriesPath).filter((d) => /^\d{4}-\d{2}-\d{2}$/.test(d));
+    for (const dateDir of dateDirs) {
+      const dirPath = path.join(entriesPath, dateDir);
+      const files = fs.readdirSync(dirPath).filter((f) => f.endsWith(".yaml"));
+      for (const file of files) {
+        try {
+          const task = yaml.load(fs.readFileSync(path.join(dirPath, file), "utf8"));
+          total++;
+          if (task.status === "open") open++;
+          else if (task.status === "done") done++;
+          else if (task.status === "shelved") shelved++;
+        } catch {
+        }
+      }
+    }
+  }
+  const index = { version: "1.0", total, open, done, shelved, last_updated: (/* @__PURE__ */ new Date()).toISOString() };
+  fs.mkdirSync(tasksRootPath, { recursive: true });
+  fs.writeFileSync(path.join(tasksRootPath, INDEX_FILE), yaml.dump(index, { lineWidth: -1, noRefs: true }));
+  return index;
+}
+
+export {
+  loadTasks,
+  loadTask,
+  createTask,
+  updateTask,
+  completeTask,
+  shelveTask,
+  rebuildTaskIndex
+};

package/dist/chunk-DSXS42FY.js

@@ -0,0 +1,283 @@
+#!/usr/bin/env node
+
+// ../paradigm-mcp/src/utils/assessment-loader.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "js-yaml";
+var ASSESSMENTS_DIR = ".paradigm/assessments";
+var ARCS_DIR = "arcs";
+var INDEX_FILE = "index.yaml";
+function generateAssessmentId(rootDir, dateStr) {
+  const arcsPath = path.join(rootDir, ASSESSMENTS_DIR, ARCS_DIR);
+  let maxSeq = 0;
+  if (fs.existsSync(arcsPath)) {
+    const arcDirs = fs.readdirSync(arcsPath).filter((d) => {
+      try {
+        return fs.statSync(path.join(arcsPath, d)).isDirectory();
+      } catch {
+        return false;
+      }
+    });
+    for (const arcDir of arcDirs) {
+      const entriesPath = path.join(arcsPath, arcDir, "entries");
+      if (!fs.existsSync(entriesPath)) continue;
+      const files = fs.readdirSync(entriesPath).filter(
+        (f) => f.startsWith(`A-${dateStr}-`) && f.endsWith(".yaml")
+      );
+      for (const file of files) {
+        const match = file.match(/A-\d{4}-\d{2}-\d{2}-(\d+)\.yaml/);
+        if (match) {
+          const seq = parseInt(match[1], 10);
+          if (seq > maxSeq) maxSeq = seq;
+        }
+      }
+    }
+  }
+  return `A-${dateStr}-${String(maxSeq + 1).padStart(3, "0")}`;
+}
+function computeArcStats(rootDir, arc) {
+  const entriesPath = path.join(rootDir, ASSESSMENTS_DIR, ARCS_DIR, arc.id, "entries");
+  const symbolSet = /* @__PURE__ */ new Set();
+  let entryCount = 0;
+  let latestDate;
+  if (fs.existsSync(entriesPath)) {
+    const files = fs.readdirSync(entriesPath).filter((f) => f.endsWith(".yaml"));
+    for (const file of files) {
+      try {
+        const entry = yaml.load(fs.readFileSync(path.join(entriesPath, file), "utf8"));
+        entryCount++;
+        if (entry.symbols) entry.symbols.forEach((s) => symbolSet.add(s));
+        if (!latestDate || entry.date > latestDate) latestDate = entry.date;
+      } catch {
+      }
+    }
+  }
+  return { ...arc, entry_count: entryCount, symbols: Array.from(symbolSet), latest_entry: latestDate };
+}
+async function loadArcs(rootDir, status) {
+  const arcsPath = path.join(rootDir, ASSESSMENTS_DIR, ARCS_DIR);
+  if (!fs.existsSync(arcsPath)) return [];
+  const arcDirs = fs.readdirSync(arcsPath).filter((d) => {
+    try {
+      return fs.statSync(path.join(arcsPath, d)).isDirectory();
+    } catch {
+      return false;
+    }
+  });
+  const arcs = [];
+  for (const arcDir of arcDirs) {
+    const arcFile = path.join(arcsPath, arcDir, "arc.yaml");
+    if (!fs.existsSync(arcFile)) continue;
+    try {
+      const arc = yaml.load(fs.readFileSync(arcFile, "utf8"));
+      if (status && status !== "all" && arc.status !== status) continue;
+      arcs.push(computeArcStats(rootDir, arc));
+    } catch {
+    }
+  }
+  arcs.sort((a, b) => {
+    const aDate = a.latest_entry || a.created;
+    const bDate = b.latest_entry || b.created;
+    return bDate.localeCompare(aDate);
+  });
+  return arcs;
+}
+async function loadArc(rootDir, arcId) {
+  const arcFile = path.join(rootDir, ASSESSMENTS_DIR, ARCS_DIR, arcId, "arc.yaml");
+  if (!fs.existsSync(arcFile)) return null;
+  try {
+    const arc = yaml.load(fs.readFileSync(arcFile, "utf8"));
+    return computeArcStats(rootDir, arc);
+  } catch {
+    return null;
+  }
+}
+var ARC_ID_PATTERN = /^arc-[a-z0-9-]+$/;
+async function createArc(rootDir, arc) {
+  if (!ARC_ID_PATTERN.test(arc.id)) {
+    throw new Error(`Invalid arc ID "${arc.id}": must match arc-{kebab-case} (lowercase alphanumeric + hyphens)`);
+  }
+  const arcPath = path.join(rootDir, ASSESSMENTS_DIR, ARCS_DIR, arc.id);
+  const entriesPath = path.join(arcPath, "entries");
+  fs.mkdirSync(entriesPath, { recursive: true });
+  const arcData = {
+    id: arc.id,
+    name: arc.name,
+    description: arc.description,
+    created: (/* @__PURE__ */ new Date()).toISOString(),
+    status: "active",
+    tags: arc.tags
+  };
+  fs.writeFileSync(path.join(arcPath, "arc.yaml"), yaml.dump(arcData, { lineWidth: -1, noRefs: true }));
+  await rebuildAssessmentIndex(rootDir);
+  return arc.id;
+}
+async function closeArc(rootDir, arcId, status) {
+  const arcFile = path.join(rootDir, ASSESSMENTS_DIR, ARCS_DIR, arcId, "arc.yaml");
+  if (!fs.existsSync(arcFile)) return false;
+  try {
+    const arc = yaml.load(fs.readFileSync(arcFile, "utf8"));
+    arc.status = status;
+    fs.writeFileSync(arcFile, yaml.dump(arc, { lineWidth: -1, noRefs: true }));
+    await rebuildAssessmentIndex(rootDir);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function loadEntries(rootDir, arcId) {
+  const entriesPath = path.join(rootDir, ASSESSMENTS_DIR, ARCS_DIR, arcId, "entries");
+  if (!fs.existsSync(entriesPath)) return [];
+  const entries = [];
+  const files = fs.readdirSync(entriesPath).filter((f) => f.endsWith(".yaml")).sort();
+  for (const file of files) {
+    try {
+      const entry = yaml.load(fs.readFileSync(path.join(entriesPath, file), "utf8"));
+      entries.push(entry);
+    } catch {
+    }
+  }
+  entries.sort((a, b) => b.date.localeCompare(a.date));
+  return entries;
+}
+async function loadEntry(rootDir, entryId) {
+  const arcsPath = path.join(rootDir, ASSESSMENTS_DIR, ARCS_DIR);
+  if (!fs.existsSync(arcsPath)) return null;
+  const arcDirs = fs.readdirSync(arcsPath).filter((d) => {
+    try {
+      return fs.statSync(path.join(arcsPath, d)).isDirectory();
+    } catch {
+      return false;
+    }
+  });
+  for (const arcDir of arcDirs) {
+    const entryFile = path.join(arcsPath, arcDir, "entries", `${entryId}.yaml`);
+    if (fs.existsSync(entryFile)) {
+      try {
+        const entry = yaml.load(fs.readFileSync(entryFile, "utf8"));
+        const arcFile = path.join(arcsPath, arcDir, "arc.yaml");
+        const arc = yaml.load(fs.readFileSync(arcFile, "utf8"));
+        return { entry, arc };
+      } catch {
+        return null;
+      }
+    }
+  }
+  return null;
+}
+async function recordEntry(rootDir, entry, arcName, arcDescription) {
+  const arcPath = path.join(rootDir, ASSESSMENTS_DIR, ARCS_DIR, entry.arc_id);
+  if (!fs.existsSync(path.join(arcPath, "arc.yaml"))) {
+    if (!arcName) {
+      throw new Error(`Arc "${entry.arc_id}" does not exist. Provide arc_name to create it.`);
+    }
+    await createArc(rootDir, { id: entry.arc_id, name: arcName, description: arcDescription, tags: entry.symbols });
+  }
+  const now = /* @__PURE__ */ new Date();
+  const dateStr = now.toISOString().slice(0, 10);
+  const id = generateAssessmentId(rootDir, dateStr);
+  const fullEntry = {
+    id,
+    arc_id: entry.arc_id,
+    title: entry.title,
+    summary: entry.summary,
+    body: entry.body,
+    symbols: entry.symbols,
+    tags: entry.tags,
+    linked_lore: entry.linked_lore,
+    linked_tasks: entry.linked_tasks,
+    linked_commits: entry.linked_commits,
+    date: now.toISOString(),
+    author: { type: "agent", id: "claude", model: "claude-opus-4-6" },
+    type: entry.type || "retro"
+  };
+  const entriesPath = path.join(arcPath, "entries");
+  fs.mkdirSync(entriesPath, { recursive: true });
+  fs.writeFileSync(path.join(entriesPath, `${id}.yaml`), yaml.dump(fullEntry, { lineWidth: -1, noRefs: true }));
+  await rebuildAssessmentIndex(rootDir);
+  return id;
+}
+async function searchEntries(rootDir, filter) {
+  const arcsPath = path.join(rootDir, ASSESSMENTS_DIR, ARCS_DIR);
+  if (!fs.existsSync(arcsPath)) return [];
+  const limit = filter.limit || 20;
+  const results = [];
+  const arcDirs = fs.readdirSync(arcsPath).filter((d) => {
+    try {
+      return fs.statSync(path.join(arcsPath, d)).isDirectory();
+    } catch {
+      return false;
+    }
+  });
+  for (const arcDir of arcDirs) {
+    const entriesPath = path.join(arcsPath, arcDir, "entries");
+    if (!fs.existsSync(entriesPath)) continue;
+    const files = fs.readdirSync(entriesPath).filter((f) => f.endsWith(".yaml"));
+    for (const file of files) {
+      try {
+        const entry = yaml.load(fs.readFileSync(path.join(entriesPath, file), "utf8"));
+        if (filter.symbol && !(entry.symbols || []).includes(filter.symbol)) continue;
+        if (filter.tag && !(entry.tags || []).includes(filter.tag)) continue;
+        if (filter.type && entry.type !== filter.type) continue;
+        if (filter.dateFrom && entry.date < filter.dateFrom) continue;
+        if (filter.dateTo && entry.date > filter.dateTo) continue;
+        results.push(entry);
+      } catch {
+      }
+    }
+  }
+  results.sort((a, b) => b.date.localeCompare(a.date));
+  return results.slice(0, limit);
+}
+async function rebuildAssessmentIndex(rootDir) {
+  const arcsPath = path.join(rootDir, ASSESSMENTS_DIR, ARCS_DIR);
+  const assessmentsPath = path.join(rootDir, ASSESSMENTS_DIR);
+  let totalArcs = 0, totalEntries = 0, activeArcs = 0;
+  const arcSummaries = [];
+  if (fs.existsSync(arcsPath)) {
+    const arcDirs = fs.readdirSync(arcsPath).filter((d) => {
+      try {
+        return fs.statSync(path.join(arcsPath, d)).isDirectory();
+      } catch {
+        return false;
+      }
+    });
+    for (const arcDir of arcDirs) {
+      const arcFile = path.join(arcsPath, arcDir, "arc.yaml");
+      if (!fs.existsSync(arcFile)) continue;
+      try {
+        const arc = yaml.load(fs.readFileSync(arcFile, "utf8"));
+        const entriesPath = path.join(arcsPath, arcDir, "entries");
+        const entryCount = fs.existsSync(entriesPath) ? fs.readdirSync(entriesPath).filter((f) => f.endsWith(".yaml")).length : 0;
+        totalArcs++;
+        totalEntries += entryCount;
+        if (arc.status === "active") activeArcs++;
+        arcSummaries.push({ id: arc.id, name: arc.name, status: arc.status, entries: entryCount });
+      } catch {
+      }
+    }
+  }
+  const index = {
+    version: "1.0",
+    total_arcs: totalArcs,
+    total_entries: totalEntries,
+    active_arcs: activeArcs,
+    last_updated: (/* @__PURE__ */ new Date()).toISOString(),
+    arcs: arcSummaries
+  };
+  fs.mkdirSync(assessmentsPath, { recursive: true });
+  fs.writeFileSync(path.join(assessmentsPath, INDEX_FILE), yaml.dump(index, { lineWidth: -1, noRefs: true }));
+  return index;
+}
+
+export {
+  loadArcs,
+  loadArc,
+  createArc,
+  closeArc,
+  loadEntries,
+  loadEntry,
+  recordEntry,
+  searchEntries,
+  rebuildAssessmentIndex
+};

package/dist/{chunk-4G54C4VM.js → chunk-YT3QWWKP.js}

@@ -1,35 +1,4 @@
 #!/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";
@@ -185,24 +154,34 @@ function getPluginUpdateNotice() {
   lines.push("--- PLUGIN UPDATES AVAILABLE ---");
   lines.push("Updates available for installed Claude Code plugins:");
   const pullCmds = [];
+  const reinstallCmds = [];
   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`);
+      reinstallCmds.push(`/plugin marketplace add ${r.repo}`);
     } else if (r.hasCacheStale) {
-      lines.push(`  - ${r.plugin} (${r.repo}): ${r.installedVersion} \u2192 ${r.localVersion} (restart needed)`);
+      lines.push(`  - ${r.plugin} (${r.repo}): ${r.installedVersion} \u2192 ${r.localVersion} (reinstall needed)`);
+      reinstallCmds.push(`/plugin marketplace add ${r.repo}`);
     }
   }
+  lines.push("");
+  lines.push("Tell the user about these updates and suggest the following steps:");
   if (pullCmds.length > 0) {
     lines.push("");
-    lines.push("Tell the user about these updates and suggest running:");
+    lines.push("Step 1 \u2014 Pull latest from remote:");
     lines.push(`  ${pullCmds.join(" && \\\n  ")}`);
+  }
+  if (reinstallCmds.length > 0) {
+    const stepNum = pullCmds.length > 0 ? 2 : 1;
     lines.push("");
-    lines.push("After updating, the user should restart their Claude Code session.");
-  } else {
+    lines.push(`Step ${stepNum} \u2014 Reinstall to update the cached version:`);
+    for (const cmd of reinstallCmds) {
+      lines.push(`  ${cmd}`);
+    }
     lines.push("");
-    lines.push("Restart the session to apply cached updates.");
+    lines.push(`Step ${stepNum + 1} \u2014 Restart the Claude Code session to load the new version.`);
   }
   lines.push("---");
   return lines.join("\n");
@@ -232,9 +211,6 @@ async function runPluginUpdateCheck() {
 }
 
 export {
-  __require,
-  __commonJS,
-  __toESM,
   getPluginUpdateNotice,
   schedulePluginUpdateCheck,
   runPluginUpdateCheck

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   initCommand
-} from "./chunk-IRVA7NKV.js";
+} from "./chunk-BC6XKMUA.js";
 import "./chunk-UI3XXVJ6.js";
 import "./chunk-CHSHON3O.js";
 import "./chunk-AK5M6KJB.js";
@@ -110,7 +110,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-KDVYB6CR.js");
+  const { shiftCommand } = await import("./shift-KJWSJLWN.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) => {