@wrongstack/plugins 0.281.1 → 0.282.0

package/dist/loop-breaker.js

@@ -1,20 +1,38 @@
+import { execFileSync } from 'child_process';
+
 // src/loop-breaker/index.ts
 var state = {
   lastFingerprint: null,
   streak: 0,
   recent: [],
+  pendingBlockReason: null,
+  lastDiffFingerprint: null,
+  noDiffStreak: 0,
+  lastErrorFingerprint: null,
+  repeatedErrorStreak: 0,
   invocations: 0,
+  postInvocations: 0,
   warnings: 0,
   blocks: 0,
   oscillationsDetected: 0,
+  stepBudgetBlocks: 0,
+  noDiffWarnings: 0,
+  noDiffBlocks: 0,
+  repeatedErrorWarnings: 0,
+  repeatedErrorBlocks: 0,
   hookUnregister: null
 };
 var DEFAULTS = {
   enabled: true,
-  mode: "block",
+  mode: "warn",
   warnAfter: 3,
   blockAfter: 5,
   oscillationWindow: 8,
+  maxSteps: 200,
+  noDiffWarnAfter: 6,
+  noDiffBlockAfter: 10,
+  repeatedErrorWarnAfter: 2,
+  repeatedErrorBlockAfter: 3,
   ignoreTools: []
 };
 function readConfig(raw) {
@@ -28,6 +46,11 @@ function readConfig(raw) {
     warnAfter,
     blockAfter,
     oscillationWindow: typeof r["oscillationWindow"] === "number" && r["oscillationWindow"] >= 4 ? r["oscillationWindow"] : DEFAULTS.oscillationWindow,
+    maxSteps: typeof r["maxSteps"] === "number" && r["maxSteps"] >= 0 ? Math.floor(r["maxSteps"]) : DEFAULTS.maxSteps,
+    noDiffWarnAfter: typeof r["noDiffWarnAfter"] === "number" && r["noDiffWarnAfter"] >= 1 ? Math.floor(r["noDiffWarnAfter"]) : DEFAULTS.noDiffWarnAfter,
+    noDiffBlockAfter: typeof r["noDiffBlockAfter"] === "number" && r["noDiffBlockAfter"] >= 0 ? Math.floor(r["noDiffBlockAfter"]) : DEFAULTS.noDiffBlockAfter,
+    repeatedErrorWarnAfter: typeof r["repeatedErrorWarnAfter"] === "number" && r["repeatedErrorWarnAfter"] >= 1 ? Math.floor(r["repeatedErrorWarnAfter"]) : DEFAULTS.repeatedErrorWarnAfter,
+    repeatedErrorBlockAfter: typeof r["repeatedErrorBlockAfter"] === "number" && r["repeatedErrorBlockAfter"] >= 0 ? Math.floor(r["repeatedErrorBlockAfter"]) : DEFAULTS.repeatedErrorBlockAfter,
     ignoreTools: Array.isArray(r["ignoreTools"]) ? r["ignoreTools"].filter((t) => typeof t === "string") : []
   };
 }
@@ -62,6 +85,32 @@ function isOscillating(recent, windowSize) {
   }
   return window[0] !== window[1];
 }
+var MUTATING_TOOLS = /* @__PURE__ */ new Set(["edit", "write"]);
+function hashString(value) {
+  let h = 5381;
+  const cap = Math.min(value.length, 1e6);
+  for (let i = 0; i < cap; i++) {
+    h = (h << 5) + h + value.charCodeAt(i) | 0;
+  }
+  return String(h >>> 0);
+}
+function gitDiffFingerprint(cwd) {
+  try {
+    const diff = execFileSync("git", ["diff", "--no-ext-diff", "--"], {
+      cwd,
+      encoding: "utf8",
+      timeout: 1e3,
+      maxBuffer: 1e6,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return diff.length === 0 ? "" : hashString(diff);
+  } catch {
+    return null;
+  }
+}
+function normalizeError(content) {
+  return content.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).slice(0, 12).join("\n").replace(/\b\d{2,}\b/g, "<n>").slice(0, 1e3);
+}
 var plugin = {
   name: "loop-breaker",
   version: "0.1.0",
@@ -75,8 +124,8 @@ var plugin = {
       enabled: { type: "boolean", default: true, description: "Master switch." },
       mode: {
         type: "string",
-        enum: ["block", "warn"],
-        default: "block",
+        enum: ["warn", "block"],
+        default: "warn",
         description: "block = refuse the repeated call; warn = only inject context."
       },
       warnAfter: {
@@ -97,6 +146,36 @@ var plugin = {
         default: 8,
         description: "Recent-call window length used for A-B-A-B oscillation detection."
       },
+      maxSteps: {
+        type: "number",
+        minimum: 0,
+        default: 200,
+        description: "Maximum tool steps before blocking; 0 disables the step budget."
+      },
+      noDiffWarnAfter: {
+        type: "number",
+        minimum: 1,
+        default: 6,
+        description: "Successful edit/write steps without a changed git diff before warning."
+      },
+      noDiffBlockAfter: {
+        type: "number",
+        minimum: 0,
+        default: 10,
+        description: "Successful edit/write steps without a changed git diff before blocking next step; 0 disables."
+      },
+      repeatedErrorWarnAfter: {
+        type: "number",
+        minimum: 1,
+        default: 2,
+        description: "Consecutive identical tool errors before warning."
+      },
+      repeatedErrorBlockAfter: {
+        type: "number",
+        minimum: 0,
+        default: 3,
+        description: "Consecutive identical tool errors before blocking next step; 0 disables."
+      },
       ignoreTools: {
         type: "array",
         items: { type: "string" },
@@ -109,10 +188,21 @@ var plugin = {
     state.lastFingerprint = null;
     state.streak = 0;
     state.recent = [];
+    state.pendingBlockReason = null;
+    state.lastDiffFingerprint = null;
+    state.noDiffStreak = 0;
+    state.lastErrorFingerprint = null;
+    state.repeatedErrorStreak = 0;
     state.invocations = 0;
+    state.postInvocations = 0;
     state.warnings = 0;
     state.blocks = 0;
     state.oscillationsDetected = 0;
+    state.stepBudgetBlocks = 0;
+    state.noDiffWarnings = 0;
+    state.noDiffBlocks = 0;
+    state.repeatedErrorWarnings = 0;
+    state.repeatedErrorBlocks = 0;
     if (state.hookUnregister) {
       try {
         state.hookUnregister();
@@ -126,6 +216,23 @@ var plugin = {
       const toolName = input.toolName ?? "unknown";
       if (cfg.ignoreTools.includes(toolName)) return;
       state.invocations += 1;
+      if (state.pendingBlockReason && cfg.mode === "block") {
+        const reason = state.pendingBlockReason;
+        state.pendingBlockReason = null;
+        state.blocks += 1;
+        api.metrics.counter("blocks");
+        return { decision: "block", reason };
+      }
+      if (cfg.maxSteps > 0 && state.invocations > cfg.maxSteps && cfg.mode === "block") {
+        state.blocks += 1;
+        state.stepBudgetBlocks += 1;
+        api.metrics.counter("blocks");
+        api.metrics.counter("step_budget_blocks");
+        return {
+          decision: "block",
+          reason: `loop-breaker: step budget exceeded (${state.invocations}/${cfg.maxSteps} tool calls). Stop and report what has been tried instead of continuing an unbounded loop.`
+        };
+      }
       const fp = fingerprint(toolName, input.toolInput);
       if (fp === state.lastFingerprint) {
         state.streak += 1;
@@ -165,7 +272,65 @@ var plugin = {
       }
       return;
     };
-    state.hookUnregister = api.registerHook("PreToolUse", "*", hook);
+    const postHook = (input) => {
+      if (!cfg.enabled) return;
+      const toolName = input.toolName ?? "unknown";
+      if (cfg.ignoreTools.includes(toolName)) return;
+      state.postInvocations += 1;
+      if (input.toolResult?.isError) {
+        const errorFingerprint = normalizeError(input.toolResult.content);
+        if (errorFingerprint && errorFingerprint === state.lastErrorFingerprint) {
+          state.repeatedErrorStreak += 1;
+        } else {
+          state.lastErrorFingerprint = errorFingerprint;
+          state.repeatedErrorStreak = errorFingerprint ? 1 : 0;
+        }
+        state.noDiffStreak = 0;
+        if (cfg.repeatedErrorBlockAfter > 0 && state.repeatedErrorStreak >= cfg.repeatedErrorBlockAfter && cfg.mode === "block") {
+          state.repeatedErrorBlocks += 1;
+          state.pendingBlockReason = `loop-breaker: the same tool error repeated ${state.repeatedErrorStreak} times. The next tool call is blocked so you can stop, summarize the repeated failure, and change approach.`;
+        }
+        if (state.repeatedErrorStreak >= cfg.repeatedErrorWarnAfter) {
+          state.repeatedErrorWarnings += 1;
+          api.metrics.counter("repeated_error_warnings");
+          return {
+            decision: "allow",
+            additionalContext: `loop-breaker: same error repeated ${state.repeatedErrorStreak}x. Do not retry the same command/tool unchanged; inspect the root cause or ask for help.`
+          };
+        }
+        return;
+      }
+      state.lastErrorFingerprint = null;
+      state.repeatedErrorStreak = 0;
+      if (!MUTATING_TOOLS.has(toolName)) return;
+      const diffFingerprint = gitDiffFingerprint(input.cwd ?? process.cwd());
+      if (diffFingerprint === null) return;
+      if (diffFingerprint === state.lastDiffFingerprint) {
+        state.noDiffStreak += 1;
+      } else {
+        state.lastDiffFingerprint = diffFingerprint;
+        state.noDiffStreak = 0;
+      }
+      if (cfg.noDiffBlockAfter > 0 && state.noDiffStreak >= cfg.noDiffBlockAfter && cfg.mode === "block") {
+        state.noDiffBlocks += 1;
+        state.pendingBlockReason = `loop-breaker: no diff was produced in the last ${state.noDiffStreak} mutating step(s). The next tool call is blocked because continued edits are not changing the working tree.`;
+      }
+      if (state.noDiffStreak >= cfg.noDiffWarnAfter) {
+        state.noDiffWarnings += 1;
+        api.metrics.counter("no_diff_warnings");
+        return {
+          decision: "allow",
+          additionalContext: `loop-breaker: no diff has changed for ${state.noDiffStreak} mutating step(s). Stop repeating edits; read the file/status, explain why no change is happening, or choose a different approach.`
+        };
+      }
+      return;
+    };
+    const unregisterPre = api.registerHook("PreToolUse", "*", hook);
+    const unregisterPost = api.registerHook("PostToolUse", "*", postHook);
+    state.hookUnregister = () => {
+      unregisterPre();
+      unregisterPost();
+    };
     api.tools.register({
       name: "loop_breaker_status",
       description: "Reports loop-breaker state: config, current repeat streak, and counters (warnings, blocks, oscillations).",
@@ -181,13 +346,26 @@ var plugin = {
           warnAfter: cfg.warnAfter,
           blockAfter: cfg.blockAfter,
           oscillationWindow: cfg.oscillationWindow,
+          maxSteps: cfg.maxSteps,
+          noDiffWarnAfter: cfg.noDiffWarnAfter,
+          noDiffBlockAfter: cfg.noDiffBlockAfter,
+          repeatedErrorWarnAfter: cfg.repeatedErrorWarnAfter,
+          repeatedErrorBlockAfter: cfg.repeatedErrorBlockAfter,
           ignoreTools: cfg.ignoreTools,
           currentStreak: state.streak,
+          noDiffStreak: state.noDiffStreak,
+          repeatedErrorStreak: state.repeatedErrorStreak,
           counters: {
             invocations: state.invocations,
+            postInvocations: state.postInvocations,
             warnings: state.warnings,
             blocks: state.blocks,
-            oscillationsDetected: state.oscillationsDetected
+            oscillationsDetected: state.oscillationsDetected,
+            stepBudgetBlocks: state.stepBudgetBlocks,
+            noDiffWarnings: state.noDiffWarnings,
+            noDiffBlocks: state.noDiffBlocks,
+            repeatedErrorWarnings: state.repeatedErrorWarnings,
+            repeatedErrorBlocks: state.repeatedErrorBlocks
           }
         };
       }
@@ -210,28 +388,51 @@ var plugin = {
     }
     const final = {
       invocations: state.invocations,
+      postInvocations: state.postInvocations,
       warnings: state.warnings,
       blocks: state.blocks,
-      oscillationsDetected: state.oscillationsDetected
+      oscillationsDetected: state.oscillationsDetected,
+      stepBudgetBlocks: state.stepBudgetBlocks,
+      noDiffWarnings: state.noDiffWarnings,
+      noDiffBlocks: state.noDiffBlocks,
+      repeatedErrorWarnings: state.repeatedErrorWarnings,
+      repeatedErrorBlocks: state.repeatedErrorBlocks
     };
     state.lastFingerprint = null;
     state.streak = 0;
     state.recent = [];
+    state.pendingBlockReason = null;
+    state.lastDiffFingerprint = null;
+    state.noDiffStreak = 0;
+    state.lastErrorFingerprint = null;
+    state.repeatedErrorStreak = 0;
     state.invocations = 0;
+    state.postInvocations = 0;
     state.warnings = 0;
     state.blocks = 0;
     state.oscillationsDetected = 0;
+    state.stepBudgetBlocks = 0;
+    state.noDiffWarnings = 0;
+    state.noDiffBlocks = 0;
+    state.repeatedErrorWarnings = 0;
+    state.repeatedErrorBlocks = 0;
     api.log.info("loop-breaker: teardown complete", { final });
   },
   async health() {
     return {
       ok: true,
-      message: `loop-breaker: ${state.invocations} call(s) observed, ${state.warnings} warning(s), ${state.blocks} block(s), ${state.oscillationsDetected} oscillation(s)`,
+      message: `loop-breaker: ${state.invocations} call(s) observed, ${state.warnings + state.noDiffWarnings + state.repeatedErrorWarnings} warning(s), ${state.blocks} block(s), ${state.oscillationsDetected} oscillation(s)`,
       counters: {
         invocations: state.invocations,
+        postInvocations: state.postInvocations,
         warnings: state.warnings,
         blocks: state.blocks,
-        oscillationsDetected: state.oscillationsDetected
+        oscillationsDetected: state.oscillationsDetected,
+        stepBudgetBlocks: state.stepBudgetBlocks,
+        noDiffWarnings: state.noDiffWarnings,
+        noDiffBlocks: state.noDiffBlocks,
+        repeatedErrorWarnings: state.repeatedErrorWarnings,
+        repeatedErrorBlocks: state.repeatedErrorBlocks
       }
     };
   }

package/dist/migration-planner.d.ts

@@ -0,0 +1,30 @@
+import { Plugin } from '@wrongstack/core';
+
+/**
+ * migration-planner plugin — helps plan dependency or framework migrations.
+ *
+ * The plugin reads a package CHANGELOG (project root or node_modules) and
+ * produces a migration checklist with breaking changes and recommended steps
+ * between two versions. If no changelog is available it returns a generic
+ * migration guide.
+ *
+ * Tools registered:
+ * - migration_plan   — produce a migration checklist for a package/version range
+ * - migration_status — report plugin state and counters
+ *
+ * Config (`config.extensions['migration-planner']`):
+ *
+ * ```jsonc
+ * {
+ *   "enabled": true,
+ *   "changelogPaths": ["CHANGELOG.md"],
+ *   "maxChars": 100_000
+ * }
+ * ```
+ *
+ * @public
+ */
+
+declare const plugin: Plugin;
+
+export { plugin as default };

package/dist/migration-planner.js

@@ -0,0 +1,349 @@
+import { existsSync, readFileSync } from 'fs';
+import { isAbsolute, resolve, relative } from 'path';
+
+// src/migration-planner/index.ts
+var API_VERSION = "^0.1.10";
+var state = {
+  plansGenerated: 0,
+  statusQueries: 0,
+  fallbackCount: 0,
+  lastPlan: null,
+  hookUnregister: null
+};
+var DEFAULTS = {
+  enabled: true,
+  changelogPaths: ["CHANGELOG.md"],
+  maxChars: 1e5
+};
+function readConfig(raw) {
+  if (!raw || typeof raw !== "object") return { ...DEFAULTS };
+  const r = raw;
+  return {
+    enabled: r["enabled"] !== false,
+    changelogPaths: Array.isArray(r["changelogPaths"]) ? r["changelogPaths"].filter((x) => typeof x === "string") : DEFAULTS.changelogPaths,
+    maxChars: typeof r["maxChars"] === "number" && r["maxChars"] >= 1e3 && r["maxChars"] <= 1e6 ? r["maxChars"] : DEFAULTS.maxChars
+  };
+}
+function withinProject(p) {
+  if (typeof p !== "string" || p.length === 0 || p.length > 4096) return false;
+  const root = process.cwd();
+  const resolved = isAbsolute(p) ? resolve(p) : resolve(root, p);
+  const rel = relative(root, resolved);
+  if (rel === "" || rel === ".") return true;
+  if (rel.startsWith("..")) return false;
+  if (isAbsolute(rel)) return false;
+  return true;
+}
+function normalizeVersion(v) {
+  return v.replace(/^v/i, "").trim();
+}
+function readChangelog(packageName, cfg) {
+  const candidates = cfg.changelogPaths.map((p) => p.replace(/<package>/g, packageName));
+  candidates.push(`node_modules/${packageName}/CHANGELOG.md`);
+  candidates.push(`node_modules/${packageName}/changelog.md`);
+  for (const candidate of candidates) {
+    if (!withinProject(candidate)) continue;
+    if (existsSync(candidate)) {
+      try {
+        const content = readFileSync(candidate, "utf-8");
+        return { source: candidate, content: content.slice(0, cfg.maxChars) };
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function extractVersionSections(changelog, fromVersion, toVersion) {
+  const fromNv = normalizeVersion(fromVersion);
+  const toNv = normalizeVersion(toVersion);
+  const sections = [];
+  let current = null;
+  for (const line of changelog.split(/\r?\n/)) {
+    const match = line.match(/^#{2,3}\s+(\[?v?(\d+\.\d+\.\d+[^[\]\s]*)\]?)\s*(.*)$/);
+    if (match) {
+      if (current) sections.push(current);
+      current = { version: normalizeVersion(match[2]), header: match[1], body: "" };
+    } else if (current) {
+      current.body += `${line}
+`;
+    }
+  }
+  if (current) sections.push(current);
+  if (sections.length === 0) return [changelog];
+  const relevant = [];
+  for (const section of sections) {
+    if (section.version === toNv) {
+      relevant.push(`## ${section.header}
+${section.body}`);
+    } else if (section.version === fromNv) {
+      break;
+    } else if (relevant.length > 0) {
+      relevant.push(`## ${section.header}
+${section.body}`);
+    }
+  }
+  return relevant.length > 0 ? relevant : [changelog];
+}
+function extractBreakingChanges(sectionText) {
+  const breaking = [];
+  let inBreakingSection = false;
+  for (const rawLine of sectionText.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line) {
+      inBreakingSection = false;
+      continue;
+    }
+    if (/^#{3,4}\s+(?:BREAKING\s+CHANGES?|Breaking\s+Changes?|Breaking)/i.test(line)) {
+      inBreakingSection = true;
+      continue;
+    }
+    if (/^#{1,4}\s+/.test(line)) {
+      inBreakingSection = false;
+      continue;
+    }
+    if (inBreakingSection) {
+      const item = line.replace(/^[-*]\s+/, "").replace(/^\d+\.\s+/, "");
+      if (item) breaking.push(item);
+    } else if (/^\s*[-*]\s+.*(?:BREAKING|breaking|removed|deprecated|no longer supported)/i.test(rawLine)) {
+      breaking.push(line.replace(/^[-*]\s+/, ""));
+    }
+  }
+  return breaking;
+}
+function extractRecommendedSteps(sectionText) {
+  const steps = [];
+  let inMigrationSection = false;
+  for (const rawLine of sectionText.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line) {
+      inMigrationSection = false;
+      continue;
+    }
+    if (/^#{3,4}\s+(?:Migration|Upgrade|How to|Steps|Recommended)/i.test(line)) {
+      inMigrationSection = true;
+      continue;
+    }
+    if (/^#{1,4}\s+/.test(line)) {
+      inMigrationSection = false;
+      continue;
+    }
+    if (inMigrationSection) {
+      const item = line.replace(/^[-*]\s+/, "").replace(/^\d+\.\s+/, "");
+      if (item) steps.push(item);
+    }
+  }
+  if (steps.length === 0) {
+    steps.push("Review the changelog for deprecated APIs.");
+    steps.push("Update imports and call sites to new API signatures.");
+    steps.push("Run the test suite and fix regressions.");
+    steps.push("Verify type-checking passes with the new version.");
+  }
+  return steps;
+}
+function buildGenericGuide(packageName, fromVersion, toVersion, scope) {
+  return {
+    breakingChanges: [
+      `No changelog found for ${packageName}. Unknown breaking changes between ${fromVersion} and ${toVersion}.`
+    ],
+    recommendedSteps: [
+      `Visit ${packageName} release notes or GitHub releases for ${toVersion}.`,
+      scope ? `Review ${scope} usage of ${packageName} for API changes.` : `Search the codebase for direct ${packageName} usage.`,
+      `Update ${packageName} from ${fromVersion} to ${toVersion} in package.json.`,
+      "Run install and the full test suite.",
+      "Fix type errors and runtime regressions."
+    ]
+  };
+}
+var plugin = {
+  name: "migration-planner",
+  version: "0.1.0",
+  description: "Helps plan dependency or framework migrations by reading changelogs and producing checklists",
+  apiVersion: API_VERSION,
+  capabilities: { tools: true, hooks: true },
+  defaultConfig: { ...DEFAULTS },
+  configSchema: {
+    type: "object",
+    properties: {
+      enabled: {
+        type: "boolean",
+        default: true,
+        description: "Master switch."
+      },
+      changelogPaths: {
+        type: "array",
+        items: { type: "string" },
+        default: ["CHANGELOG.md"],
+        description: "Changelog paths to try; <package> is replaced with the package name."
+      },
+      maxChars: {
+        type: "number",
+        minimum: 1e3,
+        maximum: 1e6,
+        default: 1e5,
+        description: "Maximum changelog characters to scan."
+      }
+    }
+  },
+  setup(api) {
+    state.plansGenerated = 0;
+    state.statusQueries = 0;
+    state.fallbackCount = 0;
+    state.lastPlan = null;
+    state.hookUnregister = null;
+    const cfg = readConfig(api.config.extensions?.["migration-planner"]);
+    const hook = (input) => {
+      if (!cfg.enabled) return;
+      if (input.toolResult?.isError) return;
+      const inp = input.toolInput ?? {};
+      const path = inp["path"];
+      if (!path) return;
+      const basename = path.split(/[/\\]/).pop() ?? "";
+      if (!/^(package\.json|package-lock\.json|pnpm-lock\.yaml|yarn\.lock|bun\.lockb?)$/i.test(
+        basename
+      )) {
+        return;
+      }
+      return {
+        additionalContext: `Manifest file ${basename} changed. Consider running migration_plan if a dependency version was updated.`
+      };
+    };
+    state.hookUnregister = api.registerHook("PostToolUse", "write|edit", hook);
+    api.tools.register({
+      name: "migration_plan",
+      description: "Read a package CHANGELOG and produce a migration checklist with breaking changes and recommended steps between two versions.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          packageName: {
+            type: "string",
+            description: "Name of the npm package or framework."
+          },
+          fromVersion: {
+            type: "string",
+            description: 'Current version, e.g. "1.2.3".'
+          },
+          toVersion: {
+            type: "string",
+            description: 'Target version, e.g. "2.0.0".'
+          },
+          scope: {
+            type: "string",
+            description: "Optional scope describing which parts of the project use the package."
+          }
+        },
+        required: ["packageName", "fromVersion", "toVersion"]
+      },
+      permission: "auto",
+      category: "Planning",
+      mutating: false,
+      async execute(input) {
+        if (!cfg.enabled) return { ok: false, error: "migration-planner is disabled" };
+        const packageName = String(input.packageName ?? "").trim();
+        const fromVersion = String(input.fromVersion ?? "").trim();
+        const toVersion = String(input.toVersion ?? "").trim();
+        if (!packageName || !fromVersion || !toVersion) {
+          return { ok: false, error: "packageName, fromVersion, and toVersion are required" };
+        }
+        const changelog = readChangelog(packageName, cfg);
+        let breakingChanges;
+        let recommendedSteps;
+        let source;
+        if (changelog) {
+          source = changelog.source;
+          const sections = extractVersionSections(changelog.content, fromVersion, toVersion);
+          const combined = sections.join("\n\n");
+          breakingChanges = extractBreakingChanges(combined);
+          recommendedSteps = extractRecommendedSteps(combined);
+        } else {
+          state.fallbackCount += 1;
+          source = null;
+          const guide = buildGenericGuide(packageName, fromVersion, toVersion, input.scope);
+          breakingChanges = guide.breakingChanges;
+          recommendedSteps = guide.recommendedSteps;
+        }
+        state.plansGenerated += 1;
+        state.lastPlan = {
+          packageName,
+          fromVersion,
+          toVersion,
+          scope: input.scope,
+          breakingChanges,
+          recommendedSteps,
+          changelogSource: source
+        };
+        return {
+          ok: true,
+          packageName,
+          fromVersion,
+          toVersion,
+          scope: input.scope,
+          changelogSource: source,
+          fallback: source === null,
+          breakingChanges,
+          recommendedSteps
+        };
+      }
+    });
+    api.tools.register({
+      name: "migration_status",
+      description: "Reports migration-planner state: counters, config, and last plan.",
+      inputSchema: { type: "object", properties: {} },
+      permission: "auto",
+      category: "Diagnostics",
+      mutating: false,
+      async execute() {
+        state.statusQueries += 1;
+        return {
+          ok: true,
+          enabled: cfg.enabled,
+          changelogPaths: cfg.changelogPaths,
+          maxChars: cfg.maxChars,
+          counters: {
+            plansGenerated: state.plansGenerated,
+            statusQueries: state.statusQueries,
+            fallbackCount: state.fallbackCount
+          },
+          lastPlan: state.lastPlan
+        };
+      }
+    });
+    api.log.info("migration-planner plugin loaded", {
+      version: "0.1.0",
+      changelogPaths: cfg.changelogPaths
+    });
+  },
+  teardown(api) {
+    if (state.hookUnregister) {
+      try {
+        state.hookUnregister();
+      } catch {
+      }
+      state.hookUnregister = null;
+    }
+    const final = {
+      plansGenerated: state.plansGenerated,
+      statusQueries: state.statusQueries,
+      fallbackCount: state.fallbackCount
+    };
+    state.plansGenerated = 0;
+    state.statusQueries = 0;
+    state.fallbackCount = 0;
+    state.lastPlan = null;
+    api.log.info("migration-planner: teardown complete", { final });
+  },
+  async health() {
+    return {
+      ok: true,
+      message: `migration-planner: ${state.plansGenerated} plan(s), ${state.fallbackCount} fallback(s)`,
+      counters: {
+        plansGenerated: state.plansGenerated,
+        statusQueries: state.statusQueries,
+        fallbackCount: state.fallbackCount
+      },
+      lastPlan: state.lastPlan
+    };
+  }
+};
+var migration_planner_default = plugin;
+
+export { migration_planner_default as default };