agentsys 5.8.6 → 5.9.0

package/.claude-plugin/marketplace.json

@@ -1,7 +1,7 @@
 {
   "name": "agentsys",
-  "description": "19 specialized plugins for AI workflow automation - task orchestration, PR workflow, slop detection, code review, drift detection, enhancement analysis, documentation sync, unified static analysis, perf investigations, topic research, agent config linting, cross-tool AI consultation, structured AI debate, workflow pattern learning, codebase onboarding, and contributor guidance",
-  "version": "5.8.6",
+  "description": "20 specialized plugins for AI workflow automation - task orchestration, PR workflow, slop detection, code review, drift detection, enhancement analysis, documentation sync, unified static analysis, perf investigations, topic research, agent config linting, cross-tool AI consultation, structured AI debate, workflow pattern learning, codebase onboarding, contributor guidance, and Zig language support",
+  "version": "5.9.0",
   "owner": {
     "name": "Avi Fenesh",
     "url": "https://github.com/avifenesh"
@@ -230,6 +230,17 @@
       "version": "0.1.0",
       "category": "productivity",
       "homepage": "https://github.com/agent-sh/can-i-help"
+    },
+    {
+      "name": "zig-lsp",
+      "source": {
+        "source": "url",
+        "url": "https://github.com/agent-sh/zig-lsp.git"
+      },
+      "description": "Zig language server for Claude Code via ZLS - automatic diagnostics after every edit, jump-to-definition, find-references, and hover. Requires zls in PATH",
+      "version": "0.1.0",
+      "category": "development",
+      "homepage": "https://github.com/agent-sh/zig-lsp"
     }
   ]
 }

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "agentsys",
-  "version": "5.8.6",
+  "version": "5.9.0",
   "description": "Professional-grade slash commands for Claude Code with cross-platform support",
   "keywords": [
     "workflow",

package/AGENTS.md

@@ -152,7 +152,7 @@ agentsys                # Run installer
 <agents>
 ## Agents
 
-47 agents across 19 plugins. Key agents by model:
+49 agents across 20 plugins (18 have agents; gate-and-ship is commands-only; zig-lsp is config-only with no commands or agents). Key agents by model:
 
 | Model | Agents | Use Case |
 |-------|--------|----------|

package/CHANGELOG.md

@@ -9,6 +9,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [5.9.0] - 2026-04-25
+
+### Added
+- **`zig-lsp` plugin** - Zig language server (ZLS) integration for Claude Code's `LSP` tool. Maps `.zig` and `.zon` to language `zig`; enables `enable_build_on_save` so post-edit diagnostics surface real type errors (not just parser errors); 30 s startup timeout, restart-on-crash with cap. Plugin is config-only - no slash commands, no agents, no skills - the harness's built-in `LSP` tool dispatches automatically once `zls` is on `PATH`. Marketplace entry under category `development`. Source: https://github.com/agent-sh/zig-lsp
+- Marketplace plugin count 19 -> 20 in `.claude-plugin/marketplace.json` description, `scripts/plugins.txt`, and `site/content.json` stats.
+
 ## [5.8.6] - 2026-04-23
 
 ### Added

package/README.md

@@ -19,7 +19,7 @@
 </p>
 
 <p align="center">
-  <b>19 plugins · 49 agents · 41 skills (across all repos) · 30k lines of lib code · 3,507 tests · 5 platforms</b><br>
+  <b>20 plugins · 49 agents · 41 skills (across all repos) · 30k lines of lib code · 3,507 tests · 5 platforms</b><br>
   <em>Plugins distributed as standalone repos under <a href="https://github.com/agent-sh">agent-sh</a> org - agentsys is the marketplace &amp; installer</em>
 </p>
 
@@ -45,7 +45,7 @@ AI models can write code. That's not the hard part anymore. The hard part is eve
 
 ## What This Is
 
-An agent orchestration system - 19 plugins, 49 agents (39 file-based + 10 role-based specialists in audit-project), and 41 skills that compose into structured pipelines for software development. Each plugin lives in its own standalone repo under the [agent-sh](https://github.com/agent-sh) org. agentsys is the marketplace and installer that ties them together.
+An agent orchestration system - 20 plugins, 49 agents (39 file-based + 10 role-based specialists in audit-project), and 41 skills that compose into structured pipelines for software development. Each plugin lives in its own standalone repo under the [agent-sh](https://github.com/agent-sh) org. agentsys is the marketplace and installer that ties them together.
 
 Each agent has a single responsibility, a specific model assignment, and defined inputs/outputs. Pipelines enforce phase gates so agents can't skip steps. State persists across sessions so work survives interruptions.
 

package/lib/binary/version.js

@@ -1,7 +1,7 @@
 'use strict';
 
 // Minimum binary version required by this version of agent-core
-const ANALYZER_MIN_VERSION = '0.4.0';
+const ANALYZER_MIN_VERSION = '0.3.0';
 
 // Binary name
 const BINARY_NAME = 'agent-analyzer';

package/lib/collectors/analyzer-queries.js

@@ -0,0 +1,341 @@
+/**
+ * Analyzer Queries Collector
+ *
+ * Runs the agent-analyzer `repo-intel query ...` commands we consume and
+ * returns them as a single indexed bundle. Replaces the per-file regex +
+ * git-show path in docs-patterns.js with the analyzer's symbol table and
+ * slop-fix outputs, both of which are deterministic and cross-language.
+ *
+ * All queries degrade gracefully: if the binary is missing or the map
+ * file isn't present, each field is `null` and the reason is recorded on
+ * the bundle. Callers should treat `null` as "signal unavailable" and
+ * skip the corresponding checks rather than invent fallback data.
+ *
+ * @module lib/collectors/analyzer-queries
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_OPTIONS = {
+  cwd: process.cwd()
+};
+
+// Docs that `doc-drift` flags as uncoupled by design. These are never
+// expected to co-change with code (Docusaurus snapshots, test fixtures,
+// generated rule pages, CHANGELOG is append-only). Matching these is
+// not evidence of drift; they're just not part of the live doc surface.
+const DEFAULT_DOC_DRIFT_IGNORE = [
+  /(^|\/)versioned_docs\//,
+  /(^|\/)versioned_sidebars\//,
+  /(^|\/)tests\/fixtures\//,
+  /(^|\/)__fixtures__\//,
+  /(^|\/)generated\//,
+  /\.generated\.md$/,
+  /(^|\/)CHANGELOG\.md$/i,
+  /(^|\/)node_modules\//,
+  /(^|\/)target\//,
+  /(^|\/)dist\//,
+  /(^|\/)build\//
+];
+
+function resolveStateDir(cwd) {
+  for (const dir of ['.claude', '.opencode', '.codex']) {
+    if (fs.existsSync(path.join(cwd, dir))) {
+      return dir;
+    }
+  }
+  return '.claude';
+}
+
+function resolveMapFile(cwd) {
+  return path.join(cwd, resolveStateDir(cwd), 'repo-intel.json');
+}
+
+/**
+ * Get the agent-analyzer binary runner. On main the binary is vendored
+ * at `lib/binary`; once the agentsys resolver PR lands this will switch
+ * to `../agentsys`. Returns `null` when unavailable — callers should
+ * treat the bundle as empty rather than erroring out.
+ */
+function getBinary() {
+  try {
+    // Prefer the agentsys resolver when present (post PR #21)
+    const { binary } = require('../agentsys').get();
+    if (binary) return binary;
+  } catch {
+    // agentsys resolver not available; fall through to vendored binary
+  }
+  try {
+    return require('../binary');
+  } catch {
+    return null;
+  }
+}
+
+function runJson(binary, args) {
+  try {
+    const out = binary.runAnalyzer(args);
+    return JSON.parse(out);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Normalize a repo-relative path: backslashes to forward slashes,
+ * empty/nullish input returns `''`. Centralized so every index-key
+ * construction in this module uses the same shape.
+ */
+function normalizePath(p) {
+  return (p || '').replace(/\\/g, '/');
+}
+
+/**
+ * Coerce a parsed analyzer result into an array. Nearly every query
+ * returns a JSON array, but if the analyzer hands back a non-array
+ * (error object, bare null, malformed output) we must not let the
+ * value flow into a for-of loop where it would throw. Returns `[]`
+ * for anything non-iterable.
+ */
+function asArray(v) {
+  return Array.isArray(v) ? v : [];
+}
+
+/**
+ * Run all analyzer queries sync-docs consumes and return an indexed
+ * bundle. See `DEFAULT_DOC_DRIFT_IGNORE` for the docs filtered from
+ * `docDrift`. A raw `docDriftAll` field is included so callers that
+ * need the unfiltered list (e.g. explicit `--include-versioned-docs`)
+ * can recover it without a second binary call.
+ *
+ * @param {Object} options
+ * @param {string} [options.cwd]
+ * @param {RegExp[]} [options.docDriftIgnore] - Override default ignore globs
+ * @param {number} [options.docDriftTop=50]
+ * @param {number} [options.staleDocsTop=500]
+ * @returns {{
+ *   available: boolean,
+ *   reason: string|null,
+ *   mapFile: string,
+ *   staleDocs: Array|null,
+ *   staleDocsByKey: Map<string, Object>|null,
+ *   docDrift: Array|null,
+ *   docDriftAll: Array|null,
+ *   entryPoints: Array|null,
+ *   entryPointSet: Set<string>|null,
+ *   slopFixes: Array|null,
+ *   orphanExports: Array|null,
+ *   passthroughWrappers: Array|null,
+ *   alwaysTrueConditions: Array|null,
+ *   commentedOutCode: Array|null,
+ *   staleSuppressions: Array|null
+ * }}
+ */
+function collect(options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const cwd = opts.cwd;
+  const mapFile = resolveMapFile(cwd);
+
+  // Return shape is identical whether analyzer succeeded or not; the
+  // `available` flag + `reason` tell callers which it is. Keeping the
+  // shape stable means consumers can use `?.` uniformly without having
+  // to guard per-field.
+  const empty = {
+    available: false,
+    reason: null,
+    queryErrors: [],
+    mapFile,
+    staleDocs: null,
+    staleDocsByKey: null,
+    staleDocsByDoc: null,
+    docDrift: null,
+    docDriftAll: null,
+    entryPoints: null,
+    entryPointSet: null,
+    entryPointSymbols: null,
+    slopFixes: null,
+    orphanExports: null,
+    passthroughWrappers: null,
+    alwaysTrueConditions: null,
+    commentedOutCode: null,
+    staleSuppressions: null
+  };
+
+  const binary = getBinary();
+  if (!binary) {
+    return { ...empty, reason: 'analyzer-binary-unavailable' };
+  }
+  if (!fs.existsSync(mapFile)) {
+    return { ...empty, reason: 'repo-intel-map-missing' };
+  }
+
+  const staleTop = opts.staleDocsTop ?? 500;
+  const driftTop = opts.docDriftTop ?? 50;
+
+  // Query failure tracking: if runJson returns null for any query
+  // (binary exec failure, JSON parse failure), we record it in
+  // `queryErrors` so the bundle can signal partial-success rather
+  // than pretending the empty result was "successfully empty".
+  // Callers who only care about happy-path use the category arrays
+  // directly; callers who want to reason about reliability can
+  // check `queryErrors`.
+  const queryErrors = [];
+  const runSafe = (queryName, args) => {
+    const raw = runJson(binary, args);
+    if (raw === null) {
+      queryErrors.push(queryName);
+    }
+    return raw;
+  };
+
+  const staleDocs = asArray(runSafe('stale-docs', [
+    'repo-intel', 'query', 'stale-docs',
+    '--top', String(staleTop),
+    '--map-file', mapFile,
+    cwd
+  ]));
+
+  const docDriftAll = asArray(runSafe('doc-drift', [
+    'repo-intel', 'query', 'doc-drift',
+    '--top', String(driftTop),
+    '--map-file', mapFile,
+    cwd
+  ]));
+
+  const entryPoints = asArray(runSafe('entry-points', [
+    'repo-intel', 'query', 'entry-points',
+    '--map-file', mapFile,
+    cwd
+  ]));
+
+  const slopRaw = runSafe('slop-fixes', [
+    'repo-intel', 'query', 'slop-fixes',
+    '--map-file', mapFile,
+    cwd
+  ]);
+  // slop-fixes returns either a bare array or `{fixes, by_file}`.
+  const slopFixes = Array.isArray(slopRaw)
+    ? slopRaw
+    : asArray(slopRaw?.fixes);
+
+  // Index stale-docs by "doc:line:reference" for O(1) lookup during
+  // per-file issue analysis. Also keep a second index by doc path.
+  // Both keys normalize backslashes to forward slashes so Windows-path
+  // output from the analyzer matches the normalized paths call sites
+  // construct in docs-patterns.js.
+  const staleDocsByKey = new Map();
+  const staleDocsByDoc = new Map();
+  for (const entry of staleDocs) {
+    const normalizedDoc = normalizePath(entry.doc);
+    entry.doc = normalizedDoc;
+    const key = `${normalizedDoc}:${entry.line}:${entry.reference}`;
+    staleDocsByKey.set(key, entry);
+    if (!staleDocsByDoc.has(normalizedDoc)) {
+      staleDocsByDoc.set(normalizedDoc, []);
+    }
+    staleDocsByDoc.get(normalizedDoc).push(entry);
+  }
+
+  // Entry-point sets are keyed on normalized paths so lookups from
+  // `findUndocumentedExports` (which normalizes the file path before
+  // lookup) succeed on Windows. `entryPointSymbols` is `path:name`; it
+  // MUST use the same normalization as the set to keep lookups
+  // consistent.
+  const entryPointSet = new Set();
+  const entryPointSymbols = new Set();
+  for (const ep of entryPoints) {
+    const normalizedPath = normalizePath(ep.path);
+    if (normalizedPath) entryPointSet.add(normalizedPath);
+    if (ep.name && normalizedPath) {
+      entryPointSymbols.add(`${normalizedPath}:${ep.name}`);
+    }
+  }
+
+  // Filter doc-drift using ignore globs. The unfiltered list stays on
+  // `docDriftAll` so callers can opt back into it.
+  const ignore = opts.docDriftIgnore || DEFAULT_DOC_DRIFT_IGNORE;
+  const docDrift = docDriftAll.filter((entry) => {
+    const p = normalizePath(entry.path);
+    return !ignore.some((re) => re.test(p));
+  });
+
+  // Partition slop-fixes by category so consumers don't re-scan.
+  // Single-pass loop - each category string lives in exactly one
+  // place (SLOP_CATEGORY_MAP), and we walk the fixes once instead
+  // of once per category. Covers the four categories plus
+  // staleSuppression added in agent-analyzer v0.7.
+  const SLOP_CATEGORY_MAP = {
+    'orphan-export': 'orphanExports',
+    'passthrough-wrapper': 'passthroughWrappers',
+    'always-true-condition': 'alwaysTrueConditions',
+    'commented-out-code': 'commentedOutCode',
+    'stale-suppression': 'staleSuppressions'
+  };
+  const orphanExports = [];
+  const passthroughWrappers = [];
+  const alwaysTrueConditions = [];
+  const commentedOutCode = [];
+  const staleSuppressions = [];
+  const bucketByKey = {
+    orphanExports,
+    passthroughWrappers,
+    alwaysTrueConditions,
+    commentedOutCode,
+    staleSuppressions
+  };
+  for (const fix of slopFixes) {
+    const key = SLOP_CATEGORY_MAP[fix.category];
+    if (key) bucketByKey[key].push(fix);
+  }
+
+  // `available` is true when at least one query succeeded and we
+  // have a usable bundle. `queryErrors` lists which specific queries
+  // failed so callers can distinguish "binary missing entirely"
+  // (empty arrays from the unavailable branch, reason set) from
+  // "some queries succeeded, some failed" (partial bundle).
+  const available = queryErrors.length < 4;
+  return {
+    available,
+    reason: available ? null : 'all-queries-failed',
+    queryErrors,
+    mapFile,
+    staleDocs,
+    staleDocsByKey,
+    staleDocsByDoc,
+    docDrift,
+    docDriftAll,
+    entryPoints,
+    entryPointSet,
+    entryPointSymbols,
+    slopFixes,
+    orphanExports,
+    passthroughWrappers,
+    alwaysTrueConditions,
+    commentedOutCode,
+    staleSuppressions
+  };
+}
+
+/**
+ * Check whether a given (path, symbol) pair is an entry point. Used by
+ * undocumented-export filtering to skip `main()`, CLI commands, and
+ * framework-loaded config files that don't need prose docs.
+ */
+function isEntryPointSymbol(bundle, filePath, symbolName) {
+  if (!bundle?.entryPointSymbols) return false;
+  const normalized = normalizePath(filePath);
+  return bundle.entryPointSymbols.has(`${normalized}:${symbolName}`)
+    || bundle.entryPointSet.has(normalized);
+}
+
+module.exports = {
+  DEFAULT_OPTIONS,
+  DEFAULT_DOC_DRIFT_IGNORE,
+  collect,
+  isEntryPointSymbol,
+  resolveMapFile,
+  resolveStateDir
+};

package/lib/collectors/documentation.js

@@ -8,7 +8,6 @@
  */
 
 'use strict';
-const { truncate } = require('../cross-platform');
 
 const fs = require('fs');
 const path = require('path');
@@ -109,7 +108,7 @@ function extractPlans(result, content) {
   for (const pattern of planPatterns) {
     let match;
     while ((match = pattern.exec(content)) !== null && result.plans.length < 15) {
-      const plan = truncate(match[1] || match[0], 100);
+      const plan = (match[1] || match[0]).slice(0, 100);
       result.plans.push(plan);
     }
   }

package/lib/collectors/github.js

@@ -9,8 +9,6 @@
 
 'use strict';
 
-const { truncate } = require('../cross-platform');
-
 const { execFileSync } = require('child_process');
 
 const DEFAULT_OPTIONS = {
@@ -49,7 +47,7 @@ function execGhWithResult(args, options = {}) {
         error: {
           type: 'parse',
           message: `Failed to parse gh output as JSON: ${error.message}`,
-          raw: truncate(output, 500)
+          raw: output.slice(0, 500)
         }
       };
     }
@@ -96,7 +94,7 @@ function summarizeIssue(item) {
     milestone: item.milestone?.title || item.milestone || null,
     createdAt: item.createdAt,
     updatedAt: item.updatedAt,
-    snippet: item.body ? truncate(item.body.replace(/\n/g, ' '), 200) : ''
+    snippet: item.body ? item.body.slice(0, 200).replace(/\n/g, ' ').trim() + (item.body.length > 200 ? '...' : '') : ''
   };
 }
 
@@ -114,7 +112,7 @@ function summarizePR(item) {
     createdAt: item.createdAt,
     updatedAt: item.updatedAt,
     files: item.files || [],
-    snippet: item.body ? truncate(item.body.replace(/\n/g, ' '), 150) : ''
+    snippet: item.body ? item.body.slice(0, 150).replace(/\n/g, ' ').trim() + (item.body.length > 150 ? '...' : '') : ''
   };
 }
 

package/lib/collectors/index.js

@@ -14,6 +14,7 @@ const documentation = require('./documentation');
 const codebase = require('./codebase');
 const docsPatterns = require('./docs-patterns');
 const git = require('./git');
+const analyzerQueries = require('./analyzer-queries');
 
 const DEFAULT_OPTIONS = {
   collectors: ['github', 'docs', 'code'],
@@ -52,9 +53,18 @@ function collect(options = {}) {
     docs: null,
     code: null,
     docsPatterns: null,
-    git: null
+    git: null,
+    analyzer: null
   };
 
+  // Analyzer signals are batched first so downstream collectors can
+  // consume the bundle via `opts.analyzer` (docs-patterns reads it
+  // for stale-docs lookup + entry-point filtering).
+  if (collectors.includes('analyzer')) {
+    data.analyzer = analyzerQueries.collect(opts);
+    opts.analyzer = data.analyzer;
+  }
+
   // Collect from each enabled collector
   if (collectors.includes('github')) {
     data.github = github.scanGitHubState(opts);
@@ -110,6 +120,7 @@ module.exports = {
   codebase,
   docsPatterns,
   git,
+  analyzerQueries,
 
   // Re-export commonly used functions for convenience
   scanGitHubState: github.scanGitHubState,

package/lib/cross-platform/index.js

@@ -310,11 +310,12 @@ function formatSection(title, content) {
  * @returns {string} Truncated text
  */
 function truncate(text, maxLength) {
-  // Code-point safe: uses spread operator to avoid splitting surrogate pairs (emoji, flags, CJK).
-  if (maxLength < 0) return text;
-  const chars = [...text];
-  if (chars.length <= maxLength) return text;
-  return chars.slice(0, maxLength - 3).join('') + '...';
+  // Negative or zero maxLength: return original text unchanged
+  if (maxLength <= 0) return text;
+  // Use Array.from to iterate over code points (handles emoji/surrogate pairs)
+  const codePoints = Array.from(text);
+  if (codePoints.length <= maxLength) return text;
+  return codePoints.slice(0, maxLength - 3).join('') + '...';
 }
 
 /**

package/lib/enhance/cross-file-analyzer.js

@@ -12,7 +12,6 @@ const fs = require('fs');
 const path = require('path');
 const { parseMarkdownFrontmatter } = require('./agent-analyzer');
 const { crossFilePatterns, loadKnownTools } = require('./cross-file-patterns');
-const { truncate } = require('../cross-platform');
 
 // ============================================
 // CONSTANTS
@@ -651,9 +650,9 @@ function analyzePromptConsistency(agents) {
       // Extract action keywords
       let action;
       if (isAlways) {
-        action = truncate(line.replace(/.*\bALWAYS\b\s*/i, ''), ACTION_COMPARISON_LENGTH);
+        action = line.replace(/.*\bALWAYS\b\s*/i, '').substring(0, ACTION_COMPARISON_LENGTH);
       } else {
-        action = truncate(line.replace(/.*\b(?:NEVER|DO NOT)\b\s*/i, ''), ACTION_COMPARISON_LENGTH);
+        action = line.replace(/.*\b(?:NEVER|DO NOT)\b\s*/i, '').substring(0, ACTION_COMPARISON_LENGTH);
       }
 
       // Extract significant keywords from action

package/lib/enhance/cross-file-patterns.js

@@ -11,7 +11,6 @@
 const fs = require('fs');
 const path = require('path');
 const { getStateDir, getPlatformName } = require('../platform/state-dir');
-const { truncate } = require('../cross-platform');
 
 /**
  * Platform-specific default tools
@@ -215,7 +214,7 @@ const crossFilePatterns = {
       if (!instruction || !files || files.length < 2) return null;
 
       return {
-        issue: `Duplicate instruction found in ${files.length} files: "${truncate(instruction, 50)}"`,
+        issue: `Duplicate instruction found in ${files.length} files: "${instruction.substring(0, 50)}..."`,
         fix: `Extract shared instruction to a common include or ensure intentional duplication`
       };
     }
@@ -235,7 +234,7 @@ const crossFilePatterns = {
       if (!rule1 || !rule2) return null;
 
       return {
-        issue: `Contradictory rules: "${truncate(rule1, 40)}" vs "${truncate(rule2, 40)}"`,
+        issue: `Contradictory rules: "${rule1.substring(0, 40)}..." vs "${rule2.substring(0, 40)}..."`,
         fix: `Resolve conflict between ${file1} and ${file2}`
       };
     }

package/lib/enhance/docs-patterns.js

@@ -4,8 +4,6 @@
  * @license MIT
  */
 
-const { truncate } = require('../cross-platform');
-
 function estimateTokens(text) {
   if (!text || typeof text !== 'string') return 0;
   return Math.ceil(text.length / 4);
@@ -161,7 +159,7 @@ const docsPatterns = {
         const tokens = estimateTokens(section);
         if (tokens > 1000) {
           // Get section title (first line)
-          const title = truncate(section.split('\n')[0].trim(), 50);
+          const title = section.split('\n')[0].trim().slice(0, 50);
           longSections.push({ title, tokens });
         }
       }
@@ -373,7 +371,7 @@ const docsPatterns = {
 
           // Check if starts with dangling reference
           if (/^(?:It|This|These|Those|They|The above|As mentioned)\s/i.test(firstLine)) {
-            const title = truncate(lines[0], 30);
+            const title = lines[0].slice(0, 30);
             issues.push(title);
           }
         }
@@ -463,7 +461,7 @@ const docsPatterns = {
         const tokens = estimateTokens(cleanPart);
 
         if (tokens > 500) {
-          const preview = truncate(cleanPart.trim().split('\n')[0], 50);
+          const preview = cleanPart.trim().split('\n')[0].slice(0, 50);
           longBlocks.push({ tokens, preview });
         }
       }
@@ -504,7 +502,7 @@ const docsPatterns = {
       for (let i = lateThreshold; i < totalLines; i++) {
         for (const pattern of criticalKeywords) {
           if (pattern.test(lines[i])) {
-            lateImportantLines.push(truncate(lines[i].trim(), 50));
+            lateImportantLines.push(lines[i].trim().slice(0, 50));
             break;
           }
         }

package/lib/index.js

@@ -30,7 +30,6 @@ const perf = require('./perf');
 const collectors = require('./collectors');
 const discoveryModule = require('./discovery');
 const binary = require('./binary');
-const repoIntel = require('./repo-intel');
 
 /**
  * Platform detection and verification utilities
@@ -256,7 +255,6 @@ module.exports = {
   collectors,
   discovery,
   binary,
-  repoIntel,
 
   // Direct module access for backward compatibility
   detectPlatform,