@wrongstack/plugins 0.281.1 → 0.282.0

package/README.md

@@ -1,7 +1,7 @@
 # @wrongstack/plugins
 
 First-party plugin collection for [WrongStack](https://github.com/WrongStack/WrongStack).
-Thirty-six focused, single-purpose plugins ship in this package. Core safety
+Sixty-two focused, single-purpose plugins ship in this package. Core safety
 plugins load automatically for every `wstack` session; provider-wire plugins
 are opt-in because they can change model-call semantics.
 
@@ -58,6 +58,32 @@ under the `BUILTIN_PLUGIN_FACTORIES` array. To opt out, add
 | 34 | [`prompt-firewall`](./src/prompt-firewall) | `prompt_firewall_status` | Provider runner wrapper | Opt-in provider-wire prompt/secret scanning and redaction/blocking |
 | 35 | [`auto-escalate`](./src/auto-escalate) | `auto_escalate_status` | `onError` extension | Opt-in retry/escalation ladder for transient provider errors |
 | 36 | [`token-throttle`](./src/token-throttle) | `token_throttle_status` | Provider runner wrapper | Opt-in rolling-window token throttling for provider calls |
+| 37 | [`type-gate`](./src/type-gate) | `type_gate_status` | `PostToolUse` | Runs `tsc --noEmit` after `write`/`edit` to catch type regressions |
+| 38 | [`test-coverage-gate`](./src/test-coverage-gate) | `coverage_gate_status` | `PostToolUse` | Detects test-coverage regressions after source-file edits |
+| 39 | [`pr-drafter`](./src/pr-drafter) | `pr_draft` | `Stop` + event subscriptions | Drafts a pull-request description from session commits/files/diff |
+| 40 | [`agent-handoff`](./src/agent-handoff) | `handoff_note`, `handoff_status` | `subagent.done` event listener | Posts structured handoff notes when subagents finish |
+| 41 | [`knowledge-graph`](./src/knowledge-graph) | `kg_add_fact`, `kg_query`, `kg_remove_fact`, `kg_status` | System prompt contributor | Persistent structured (subject, relation, object) project facts |
+| 42 | [`dead-code-detector`](./src/dead-code-detector) | `dead_code_scan` | `PostToolUse` | Regex-based scan for exported identifiers that appear unused |
+| 43 | [`dependency-vulnerability-gate`](./src/dependency-vulnerability-gate) | `dependency_audit_status` | `PostToolUse` | Runs `npm/pnpm audit` after installs and blocks on severe vulnerabilities |
+| 44 | [`migration-planner`](./src/migration-planner) | `migration_plan`, `migration_status` | `PostToolUse` | Reads changelogs and produces version-migration checklists |
+| 45 | [`semantic-search-indexer`](./src/semantic-search-indexer) | `semantic_search`, `semantic_index_status` | — | Lightweight keyword index over project source files |
+| 46 | [`auto-i18n-extractor`](./src/auto-i18n-extractor) | `i18n_extract`, `i18n_status` | `PostToolUse` | Detects hardcoded user-facing strings and suggests i18n keys |
+| 47 | [`doc-sync-guard`](./src/doc-sync-guard) | `doc_sync_status` | `PostToolUse` | Warns when README/docs edits omit recently changed source files |
+| 48 | [`api-compatibility-gate`](./src/api-compatibility-gate) | `api_compat_status` | `PostToolUse` | Detects removed exports in entry-point files as breaking changes |
+| 49 | [`performance-regression-gate`](./src/performance-regression-gate) | `perf_regression_status` | — | Compares benchmark results and reports regressions |
+| 50 | [`test-flake-detector`](./src/test-flake-detector) | `flake_detect`, `flake_status` | — | Runs a test command N times to identify flaky tests |
+| 51 | [`schema-evolution-guard`](./src/schema-evolution-guard) | `schema_evolution_status` | `PostToolUse` | Detects destructive patterns in DB/API schema files |
+| 52 | [`license-audit-gate`](./src/license-audit-gate) | `license_audit_status` | `PostToolUse` | Audits newly added dependency licenses against an allowlist |
+| 53 | [`accessibility-auditor`](./src/accessibility-auditor) | `a11y_audit`, `a11y_status` | `PostToolUse` | Audits UI files for missing alt, labels, button text, duplicate ids |
+| 54 | [`security-hotspot-scanner`](./src/security-hotspot-scanner) | `security_hotspot_scan`, `security_hotspot_status` | `PostToolUse` | Scans source for security anti-patterns after writes/edits |
+| 55 | [`duplicate-code-detector`](./src/duplicate-code-detector) | `detect_duplicate_code`, `duplicate_code_status` | `PostToolUse` | Detects duplicate/similar code blocks using normalized-line fingerprints |
+| 56 | [`code-metrics`](./src/code-metrics) | `measure_code_metrics`, `metrics_status` | `PostToolUse` | Computes LOC, comment ratio, function count, and approximate cyclomatic complexity |
+| 57 | [`refactor-suggester`](./src/refactor-suggester) | `suggest_refactors`, `refactor_status` | `PostToolUse` | Flags long functions, deep nesting, many parameters, magic numbers, console.log |
+| 58 | [`test-generator`](./src/test-generator) | `generate_unit_tests` | — | Generates a unit-test skeleton from exported functions/classes |
+| 59 | [`release-notes-generator`](./src/release-notes-generator) | `generate_release_notes` | — | Groups conventional commits into a release-notes markdown draft |
+| 60 | [`smart-rename`](./src/smart-rename) | `smart_rename` | — | Whole-word symbol rename with preview and optional apply |
+| 61 | [`feature-flag-tracker`](./src/feature-flag-tracker) | `scan_feature_flags`, `feature_flag_status` | `PostToolUse` | Scans source files for feature-flag usage and reports flag inventory |
+| 62 | [`interface-contract-guard`](./src/interface-contract-guard) | `check_interface_contracts`, `interface_contract_status` | `PostToolUse` | Warns when TypeScript interfaces change or lack implementers |
 
 ### Removed plugins (use built-in tools instead)
 
@@ -672,7 +698,7 @@ context. Increase `includeTranscriptTail` for more history.
 Two hooks working together:
 
 **PostToolUse** (always active when the plugin is enabled):
-scans markdown files for *unlinked* references to one of the 36
+scans markdown files for *unlinked* references to one of the 62
 known plugins and surfaces them to the LLM via
 `additionalContext`. The plugin does NOT modify the file — it
 only injects a low-noise context block listing the unlinked
@@ -696,7 +722,7 @@ the PostToolUse context tells the LLM what to fix.
 
 **Detection rules** (both hooks):
 - Source matches `config.fileGlobs` (default: `**/*.md`, `**/*.mdx`)
-- The reference matches one of the 36 known plugin names
+- The reference matches one of the 62 known plugin names
   (case-insensitive)
 - It is NOT already wrapped in a markdown link `[name](...)` or
   inline code `` `name` ``

package/dist/accessibility-auditor.d.ts

@@ -0,0 +1,40 @@
+import { Plugin } from '@wrongstack/core';
+
+/**
+ * accessibility-auditor plugin — audits UI files for common accessibility
+ * issues using fast regex-based heuristics.
+ *
+ * Tools registered:
+ * - a11y_audit : Scan a file or directory for a11y issues.
+ * - a11y_status : Show config + per-session counters.
+ *
+ * Hooks registered:
+ * - PostToolUse with matcher `write|edit` to UI files, injecting a short
+ *   additionalContext summary of any new accessibility issues.
+ *
+ * Config (`config.extensions['accessibility-auditor']`):
+ *
+ * ```jsonc
+ * {
+ *   "enabled": true,
+ *   "includeExtensions": [".tsx", ".jsx", ".html", ".vue"],
+ *   "maxFindings": 50,
+ *   "severity": "warn",         // "warn" | "block"
+ *   "onWriteEdit": true
+ * }
+ * ```
+ *
+ * @public
+ */
+
+type A11yRule = 'missing-alt' | 'missing-input-label' | 'low-contrast-placeholder' | 'missing-button-text' | 'duplicate-id';
+interface A11yFinding {
+    file: string;
+    line: number;
+    rule: A11yRule;
+    severity: 'error' | 'warning';
+    message: string;
+}
+declare const plugin: Plugin;
+
+export { type A11yFinding, type A11yRule, plugin as default };

package/dist/accessibility-auditor.js

@@ -0,0 +1,411 @@
+import { existsSync, statSync, readFileSync, readdirSync } from 'fs';
+import { isAbsolute, resolve, relative } from 'path';
+
+// src/accessibility-auditor/index.ts
+var API_VERSION = "^0.1.10";
+var state = {
+  auditCount: 0,
+  fileCount: 0,
+  findingCount: 0,
+  hookInvocationCount: 0,
+  lastResult: null,
+  hookUnregister: null
+};
+var DEFAULTS = {
+  enabled: false,
+  includeExtensions: [".tsx", ".jsx", ".html", ".vue"],
+  maxFindings: 50,
+  severity: "warn",
+  onWriteEdit: true
+};
+function readConfig(raw) {
+  if (!raw || typeof raw !== "object") return { ...DEFAULTS };
+  const r = raw;
+  return {
+    enabled: r["enabled"] !== false,
+    includeExtensions: Array.isArray(r["includeExtensions"]) ? r["includeExtensions"].filter((x) => typeof x === "string") : DEFAULTS.includeExtensions,
+    maxFindings: typeof r["maxFindings"] === "number" && r["maxFindings"] >= 1 && r["maxFindings"] <= 500 ? r["maxFindings"] : DEFAULTS.maxFindings,
+    severity: r["severity"] === "block" ? "block" : DEFAULTS.severity,
+    onWriteEdit: r["onWriteEdit"] !== false
+  };
+}
+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 normalizeExtensions(exts) {
+  return exts.map((e) => e.startsWith(".") ? e.toLowerCase() : `.${e.toLowerCase()}`);
+}
+function matchesExtension(p, exts) {
+  const dot = p.lastIndexOf(".");
+  if (dot === -1) return false;
+  return exts.includes(p.slice(dot).toLowerCase());
+}
+function collectUiFiles(root, exts) {
+  const files = [];
+  if (!existsSync(root)) return files;
+  const s = statSync(root);
+  if (s.isFile()) {
+    if (matchesExtension(root, exts)) files.push(root);
+    return files;
+  }
+  if (!s.isDirectory()) return files;
+  function walk(dir) {
+    let entries;
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = resolve(dir, entry);
+      let st;
+      try {
+        st = statSync(full);
+      } catch {
+        continue;
+      }
+      if (st.isDirectory()) {
+        walk(full);
+      } else if (st.isFile() && matchesExtension(full, exts)) {
+        files.push(full);
+      }
+    }
+  }
+  walk(root);
+  return files;
+}
+var TAG_IMG = /<img\b[^>]*>/gi;
+var TAG_INPUT = /<input\b[^>]*\/?>/gi;
+var TAG_BUTTON = /<button\b[^>]*>([\s\S]*?)<\/button>/gi;
+var INPUT_BUTTON = /<input\b[^>]*\btype\s*=\s*["'](submit|button|reset)["'][^>]*\/?>/gi;
+var ATTR_ID = /\bid\s*=\s*["']([^"']+)["']/gi;
+var ATTR_ALT = /\balt\s*=/i;
+var ATTR_ARIA_LABEL = /\b(?:aria-label|aria-labelledby)\s*=/i;
+var ATTR_TITLE = /\btitle\s*=/i;
+var ATTR_PLACEHOLDER = /\bplaceholder\s*=/i;
+var ATTR_VALUE = /\bvalue\s*=/i;
+function hasMeaningfulAlt(tag) {
+  const m = ATTR_ALT.exec(tag);
+  ATTR_ALT.lastIndex = 0;
+  if (!m) return false;
+  const valMatch = tag.match(/\balt\s*=\s*["']?([^"'\s>]*)["']?/i);
+  return valMatch ? valMatch[1].trim().length > 0 : false;
+}
+function auditFile(filePath, projectRoot) {
+  let content;
+  try {
+    content = readFileSync(filePath, "utf-8");
+  } catch {
+    return [];
+  }
+  const findings = [];
+  const lines = content.split(/\r?\n/);
+  const idsByValue = /* @__PURE__ */ new Map();
+  function add(line, rule, severity, message) {
+    findings.push({
+      file: relative(projectRoot, filePath),
+      line,
+      rule,
+      severity,
+      message
+    });
+  }
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNo = i + 1;
+    let idMatch;
+    while ((idMatch = ATTR_ID.exec(line)) !== null) {
+      const id = idMatch[1];
+      const list = idsByValue.get(id) ?? [];
+      list.push(lineNo);
+      idsByValue.set(id, list);
+    }
+    ATTR_ID.lastIndex = 0;
+    let imgMatch;
+    while ((imgMatch = TAG_IMG.exec(line)) !== null) {
+      const tag = imgMatch[0];
+      if (!hasMeaningfulAlt(tag)) {
+        add(lineNo, "missing-alt", "error", "<img> is missing meaningful alt text");
+      }
+    }
+    TAG_IMG.lastIndex = 0;
+    let inputMatch;
+    while ((inputMatch = TAG_INPUT.exec(line)) !== null) {
+      const tag = inputMatch[0];
+      const typeMatch = tag.match(/\btype\s*=\s*["']?([^"'\s>]*)["']?/i);
+      const type = typeMatch ? typeMatch[1].toLowerCase() : "text";
+      if (type === "hidden" || type === "button" || type === "submit" || type === "reset" || type === "image") {
+        continue;
+      }
+      const hasAriaLabel = ATTR_ARIA_LABEL.test(tag);
+      const hasTitle = ATTR_TITLE.test(tag);
+      const idMatchLocal = tag.match(/\bid\s*=\s*["']([^"']+)["']/i);
+      const id = idMatchLocal ? idMatchLocal[1] : null;
+      let hasLabelFor = false;
+      if (id) {
+        const labelForRe = new RegExp(`<label\\b[^>]*\\bfor\\s*=\\s*["']${id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["']`, "i");
+        hasLabelFor = labelForRe.test(content);
+      }
+      const wrappedInLabel = /<label\b[\s\S]*?<input\b[\s\S]*?<\/label>/i.test(content);
+      if (!hasAriaLabel && !hasTitle && !hasLabelFor && !wrappedInLabel) {
+        add(lineNo, "missing-input-label", "error", `<input type="${type}"> is missing an associated label`);
+      }
+      if (ATTR_PLACEHOLDER.test(tag)) {
+        add(lineNo, "low-contrast-placeholder", "warning", "<input> uses placeholder text (often low contrast and disappears on input)");
+      }
+    }
+    TAG_INPUT.lastIndex = 0;
+    let buttonMatch;
+    while ((buttonMatch = TAG_BUTTON.exec(line)) !== null) {
+      const tag = buttonMatch[0];
+      const inner = buttonMatch[1] ?? "";
+      const hasText = inner.replace(/\s+/g, "").length > 0;
+      const hasAriaLabel = ATTR_ARIA_LABEL.test(tag);
+      const hasTitle = ATTR_TITLE.test(tag);
+      if (!hasText && !hasAriaLabel && !hasTitle) {
+        add(lineNo, "missing-button-text", "error", "<button> has no visible text or accessible label");
+      }
+    }
+    TAG_BUTTON.lastIndex = 0;
+    let inputButtonMatch;
+    while ((inputButtonMatch = INPUT_BUTTON.exec(line)) !== null) {
+      const tag = inputButtonMatch[0];
+      if (!ATTR_VALUE.test(tag) && !ATTR_ARIA_LABEL.test(tag) && !ATTR_TITLE.test(tag)) {
+        add(lineNo, "missing-button-text", "error", `<input type="${inputButtonMatch[1]}"> is missing value/aria-label/title`);
+      }
+    }
+    INPUT_BUTTON.lastIndex = 0;
+  }
+  for (const [id, lineNos] of idsByValue.entries()) {
+    if (lineNos.length > 1) {
+      for (const lineNo of lineNos) {
+        add(lineNo, "duplicate-id", "error", `Duplicate id "${id}"`);
+      }
+    }
+  }
+  return findings;
+}
+function auditPath(rawPath, cfg) {
+  const root = process.cwd();
+  const resolved = isAbsolute(rawPath) ? resolve(rawPath) : resolve(root, rawPath);
+  const exts = normalizeExtensions(cfg.includeExtensions);
+  const files = collectUiFiles(resolved, exts);
+  const findings = [];
+  for (const file of files) {
+    const fileFindings = auditFile(file, root);
+    findings.push(...fileFindings);
+    if (findings.length >= cfg.maxFindings) break;
+  }
+  return {
+    path: relative(root, resolved),
+    findings: findings.slice(0, cfg.maxFindings),
+    fileCount: files.length
+  };
+}
+function formatSummary(result) {
+  if (result.findings.length === 0) {
+    return `
+\u2705 accessibility-auditor: no issues found in ${result.path} (${result.fileCount} file${result.fileCount === 1 ? "" : "s"}).`;
+  }
+  const lines = result.findings.map((f) => `  - ${f.file}:${f.line} \u2014 ${f.message} (${f.rule})`);
+  return `
+\u26A0\uFE0F accessibility-auditor: ${result.findings.length} issue(s) in ${result.path} (${result.fileCount} file${result.fileCount === 1 ? "" : "s"}):
+` + lines.join("\n") + "\nConsider adding missing labels/alt text or resolving duplicate ids.";
+}
+var plugin = {
+  name: "accessibility-auditor",
+  version: "0.1.0",
+  description: "Audits .tsx/.jsx/.html/.vue files for common accessibility issues and reports findings after writes/edits",
+  apiVersion: API_VERSION,
+  capabilities: { tools: true, hooks: true },
+  defaultConfig: { ...DEFAULTS },
+  configSchema: {
+    type: "object",
+    properties: {
+      enabled: {
+        type: "boolean",
+        default: true,
+        description: "Master switch."
+      },
+      includeExtensions: {
+        type: "array",
+        items: { type: "string" },
+        default: [".tsx", ".jsx", ".html", ".vue"],
+        description: "File extensions to audit."
+      },
+      maxFindings: {
+        type: "number",
+        minimum: 1,
+        maximum: 500,
+        default: 50,
+        description: "Maximum findings returned per audit."
+      },
+      severity: {
+        type: "string",
+        enum: ["warn", "block"],
+        default: "warn",
+        description: "warn = inject findings as additionalContext; block = refuse the mutating tool when issues appear."
+      },
+      onWriteEdit: {
+        type: "boolean",
+        default: true,
+        description: "Run audit after write|edit to UI files."
+      }
+    }
+  },
+  setup(api) {
+    state.auditCount = 0;
+    state.fileCount = 0;
+    state.findingCount = 0;
+    state.hookInvocationCount = 0;
+    state.lastResult = null;
+    state.hookUnregister = null;
+    const cfg = readConfig(api.config.extensions?.["accessibility-auditor"]);
+    const hook = (input) => {
+      if (!cfg.enabled || !cfg.onWriteEdit) return;
+      if (input.toolResult?.isError) return;
+      const inp = input.toolInput ?? {};
+      const sourcePath = inp["path"];
+      if (!sourcePath || typeof sourcePath !== "string") return;
+      if (!withinProject(sourcePath)) return;
+      const exts = normalizeExtensions(cfg.includeExtensions);
+      if (!matchesExtension(sourcePath, exts)) return;
+      state.hookInvocationCount += 1;
+      const result = auditPath(sourcePath, cfg);
+      state.auditCount += 1;
+      state.fileCount += result.fileCount;
+      state.findingCount += result.findings.length;
+      state.lastResult = {
+        path: result.path,
+        fileCount: result.fileCount,
+        findingCount: result.findings.length,
+        when: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      if (result.findings.length === 0) return;
+      const summary = formatSummary(result);
+      if (cfg.severity === "block") {
+        return { decision: "block", reason: summary };
+      }
+      return { additionalContext: summary };
+    };
+    state.hookUnregister = api.registerHook("PostToolUse", "write|edit", hook);
+    api.tools.register({
+      name: "a11y_audit",
+      description: "Audit a file or directory for accessibility issues. Scans .tsx/.jsx/.html/.vue files for missing alt text, missing labels, low-contrast placeholders, missing button text, and duplicate ids.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: "File or directory path to audit (relative to project root)."
+          }
+        },
+        required: ["path"]
+      },
+      permission: "auto",
+      category: "Diagnostics",
+      mutating: false,
+      async execute(input) {
+        if (!cfg.enabled) return { ok: false, error: "accessibility-auditor is disabled" };
+        const rawPath = input.path;
+        if (!rawPath || typeof rawPath !== "string") {
+          return { ok: false, error: "path is required" };
+        }
+        if (!withinProject(rawPath)) {
+          return { ok: false, error: "path must be inside the project" };
+        }
+        state.auditCount += 1;
+        const result = auditPath(rawPath, cfg);
+        state.fileCount += result.fileCount;
+        state.findingCount += result.findings.length;
+        state.lastResult = {
+          path: result.path,
+          fileCount: result.fileCount,
+          findingCount: result.findings.length,
+          when: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        return {
+          ok: true,
+          path: result.path,
+          fileCount: result.fileCount,
+          findingCount: result.findings.length,
+          findings: result.findings
+        };
+      }
+    });
+    api.tools.register({
+      name: "a11y_status",
+      description: "Reports accessibility-auditor state: config, per-session counters, and the most recent scan result.",
+      inputSchema: { type: "object", properties: {} },
+      permission: "auto",
+      category: "Diagnostics",
+      mutating: false,
+      async execute() {
+        return {
+          ok: true,
+          enabled: cfg.enabled,
+          includeExtensions: cfg.includeExtensions,
+          maxFindings: cfg.maxFindings,
+          severity: cfg.severity,
+          onWriteEdit: cfg.onWriteEdit,
+          counters: {
+            audits: state.auditCount,
+            files: state.fileCount,
+            findings: state.findingCount,
+            hookInvocations: state.hookInvocationCount
+          },
+          lastResult: state.lastResult
+        };
+      }
+    });
+    api.log.info("accessibility-auditor plugin loaded", {
+      version: "0.1.0",
+      includeExtensions: cfg.includeExtensions,
+      severity: cfg.severity
+    });
+  },
+  teardown(api) {
+    if (state.hookUnregister) {
+      try {
+        state.hookUnregister();
+      } catch {
+      }
+      state.hookUnregister = null;
+    }
+    const final = {
+      audits: state.auditCount,
+      files: state.fileCount,
+      findings: state.findingCount,
+      hookInvocations: state.hookInvocationCount
+    };
+    state.auditCount = 0;
+    state.fileCount = 0;
+    state.findingCount = 0;
+    state.hookInvocationCount = 0;
+    state.lastResult = null;
+    api.log.info("accessibility-auditor: teardown complete", { final });
+  },
+  async health() {
+    return {
+      ok: true,
+      message: state.lastResult ? `accessibility-auditor: ${state.auditCount} audit(s), last scan ${state.lastResult.path} had ${state.lastResult.findingCount} finding(s)` : `accessibility-auditor: ${state.auditCount} audit(s), ${state.findingCount} finding(s)`,
+      counters: {
+        audits: state.auditCount,
+        files: state.fileCount,
+        findings: state.findingCount,
+        hookInvocations: state.hookInvocationCount
+      },
+      lastResult: state.lastResult
+    };
+  }
+};
+var accessibility_auditor_default = plugin;
+
+export { accessibility_auditor_default as default };

package/dist/agent-handoff.d.ts

@@ -0,0 +1,37 @@
+import { Plugin } from '@wrongstack/core';
+
+/**
+ * agent-handoff plugin — turns subagent completions into structured
+ * handoff notes for the next agent.
+ *
+ * When a subagent finishes (`subagent.done` event), this plugin extracts
+ * its identity, task, result, and any todo context, then posts a compact
+ * mailbox message addressed to the parent/leader agent so the next
+ * worker or the leader can pick up where it left off.
+ *
+ * Tools registered:
+ * - handoff_note : Manually compose and send a handoff note.
+ * - handoff_status : Counters + last handoff id.
+ *
+ * Events subscribed:
+ * - `subagent.done`
+ *
+ * Config (`config.extensions['agent-handoff']`):
+ *
+ * ```jsonc
+ * {
+ *   "enabled": true,
+ *   "subjectPrefix": "handoff: ",
+ *   "includeResult": true,
+ *   "includeTodos": true,
+ *   "maxBodyChars": 4000,
+ *   "to": "leader"   // default recipient alias
+ * }
+ * ```
+ *
+ * @public
+ */
+
+declare const plugin: Plugin;
+
+export { plugin as default };