agentsys 5.0.0 → 5.0.2

package/adapters/opencode/skills/perf-theory-gatherer/SKILL.md

@@ -2,7 +2,7 @@
 ---
 name: perf-theory-gatherer
 description: "Use when generating performance hypotheses backed by git history and code evidence."
-version: 5.0.0
+version: 5.0.2
 ---
 
 # perf-theory-gatherer

package/adapters/opencode/skills/perf-theory-tester/SKILL.md

@@ -2,7 +2,7 @@
 ---
 name: perf-theory-tester
 description: "Use when running controlled perf experiments to validate hypotheses."
-version: 5.0.0
+version: 5.0.2
 ---
 
 # perf-theory-tester

package/adapters/opencode/skills/sync-docs/SKILL.md

@@ -2,7 +2,7 @@
 ---
 name: sync-docs
 description: "Sync documentation with code. Use when user asks to update docs, check docs, fix stale documentation, update changelog, or after code changes."
-version: 5.0.0
+version: 5.0.2
 argument-hint: "[report|apply] [--scope=all|recent|before-pr] [--include-undocumented]"
 allowed-tools: Bash(git:*), Read, Grep, Glob
 ---

package/adapters/opencode/skills/validate-delivery/SKILL.md

@@ -1,8 +1,8 @@
 <!-- AUTO-GENERATED by scripts/gen-adapters.js - DO NOT EDIT -->
 ---
 name: validate-delivery
-description: "Use when validating task completion before shipping. Runs tests, build, and requirement checks. Returns pass/fail with fix instructions."
-version: 5.0.0
+description: "Use when user asks to \"validate delivery\", \"check readiness\", or \"verify completion\". Runs tests, build, and requirement checks with pass/fail instructions."
+version: 5.0.2
 ---
 
 # validate-delivery

package/bin/cli.js

@@ -214,10 +214,17 @@ function installForClaude() {
 
     // Discover plugins from filesystem convention
     const plugins = discovery.discoverPlugins(PACKAGE_DIR);
+    const failedPlugins = [];
     for (const plugin of plugins) {
       // Validate plugin name before shell use (prevents injection)
       if (!/^[a-z0-9][a-z0-9-]*$/.test(plugin)) continue;
       console.log(`  Installing ${plugin}...`);
+      // Remove pre-rename plugin ID to prevent dual loading on upgrade
+      try {
+        execSync(`claude plugin uninstall ${plugin}@awesome-slash`, { stdio: 'pipe' });
+      } catch {
+        // Not installed under old name
+      }
       try {
         // Try install first
         execSync(`claude plugin install ${plugin}@agentsys`, { stdio: 'pipe' });
@@ -226,11 +233,17 @@ function installForClaude() {
         try {
           execSync(`claude plugin update ${plugin}@agentsys`, { stdio: 'pipe' });
         } catch {
-          // Ignore if update also fails
+          failedPlugins.push(plugin);
         }
       }
     }
 
+    if (failedPlugins.length > 0) {
+      console.log(`\n[ERROR] Failed to install/update ${failedPlugins.length} plugin(s): ${failedPlugins.join(', ')}`);
+      console.log('Retry with: /plugin install <plugin>@agentsys');
+      return false;
+    }
+
     console.log('\n[OK] Claude Code installation complete!\n');
     console.log('Commands: ' + plugins.map(p => '/' + p).join(', '));
     return true;
@@ -328,9 +341,11 @@ function installForOpenCode(installDir, options = {}) {
   // OpenCode global locations are under ~/.config/opencode (or $XDG_CONFIG_HOME/opencode).
   const commandsDir = path.join(opencodeConfigDir, 'commands');
   const pluginDir = path.join(opencodeConfigDir, 'plugins');
+  const agentsDir = path.join(opencodeConfigDir, 'agents');
 
   fs.mkdirSync(commandsDir, { recursive: true });
   fs.mkdirSync(pluginDir, { recursive: true });
+  fs.mkdirSync(agentsDir, { recursive: true });
 
   // Install native OpenCode plugin (auto-thinking, workflow enforcement, compaction)
   const pluginSrcDir = path.join(installDir, 'adapters', 'opencode-plugin');
@@ -384,10 +399,17 @@ function installForOpenCode(installDir, options = {}) {
     }
   }
 
+  // Remove legacy agent files from pre-rename installs.
+  const legacyAgentFiles = ['review.md', 'ship.md', 'workflow.md'];
+  for (const legacyFile of legacyAgentFiles) {
+    const legacyPath = path.join(agentsDir, legacyFile);
+    if (fs.existsSync(legacyPath)) {
+      fs.unlinkSync(legacyPath);
+    }
+  }
+
   // Install agents to global OpenCode location
   // OpenCode looks for agents in ~/.config/opencode/agents/ (global) or .opencode/agents/ (per-project)
-  const agentsDir = path.join(opencodeConfigDir, 'agents');
-  fs.mkdirSync(agentsDir, { recursive: true });
 
   console.log('  Installing agents for OpenCode...');
   const pluginDirs = discovery.discoverPlugins(installDir);
@@ -681,24 +703,36 @@ async function main() {
   }
 
   // Install for each platform
+  const failedPlatforms = [];
   for (const platform of selected) {
     switch (platform) {
       case 'claude':
-        if (args.development) {
-          installForClaudeDevelopment();
+        if (args.development && !installForClaudeDevelopment()) {
+          failedPlatforms.push('claude');
         } else {
-          installForClaude();
+          if (!args.development && !installForClaude()) {
+            failedPlatforms.push('claude');
+          }
         }
         break;
       case 'opencode':
-        installForOpenCode(installDir, { stripModels: args.stripModels });
+        if (!installForOpenCode(installDir, { stripModels: args.stripModels })) {
+          failedPlatforms.push('opencode');
+        }
         break;
       case 'codex':
-        installForCodex(installDir);
+        if (!installForCodex(installDir)) {
+          failedPlatforms.push('codex');
+        }
         break;
     }
   }
 
+  if (failedPlatforms.length > 0) {
+    console.log(`\n[ERROR] Installation failed for: ${failedPlatforms.join(', ')}`);
+    process.exitCode = 1;
+  }
+
   console.log('─'.repeat(45));
   if (installDir) {
     console.log(`\nInstallation directory: ${installDir}`);

package/bin/dev-cli.js

@@ -13,7 +13,8 @@
  */
 
 const path = require('path');
-const { execSync } = require('child_process');
+const { execSync, spawnSync } = require('child_process');
+const { resolveExecutableForPlatform } = require('../lib/utils/command-parser');
 
 const VERSION = require('../package.json').version;
 const ROOT_DIR = path.join(__dirname, '..');
@@ -293,13 +294,22 @@ const COMMANDS = {
     description: 'Run test suite',
     handler: (args) => {
       try {
-        const cmd = ['npm', 'test'];
+        const cmdArgs = ['test'];
         if (args.length > 0) {
-          cmd.push('--');
-          cmd.push(...args);
+          cmdArgs.push('--');
+          cmdArgs.push(...args);
         }
-        execSync(cmd.join(' '), { cwd: ROOT_DIR, stdio: 'inherit' });
-        return 0;
+        const npmExecutable = resolveExecutableForPlatform('npm');
+        const result = spawnSync(npmExecutable, cmdArgs, {
+          cwd: ROOT_DIR,
+          stdio: 'inherit',
+          shell: false,
+          windowsHide: true
+        });
+        if (result.error) {
+          throw result.error;
+        }
+        return typeof result.status === 'number' ? result.status : 1;
       } catch (err) {
         return err.status || 1;
       }

package/lib/collectors/github.js

@@ -14,6 +14,7 @@ const { execFileSync } = require('child_process');
 const DEFAULT_OPTIONS = {
   issueLimit: 100,
   prLimit: 50,
+  milestoneLimit: 100,
   timeout: 10000,
   cwd: process.cwd()
 };
@@ -25,16 +26,41 @@ const DEFAULT_OPTIONS = {
  * @returns {Object|null} Parsed JSON result or null
  */
 function execGh(args, options = {}) {
+  const result = execGhWithResult(args, options);
+  return result.ok ? result.data : null;
+}
+
+function execGhWithResult(args, options = {}) {
   try {
-    const result = execFileSync('gh', args, {
+    const output = execFileSync('gh', args, {
       encoding: 'utf8',
       stdio: 'pipe',
       timeout: options.timeout || DEFAULT_OPTIONS.timeout,
       cwd: options.cwd || DEFAULT_OPTIONS.cwd
     });
-    return JSON.parse(result);
-  } catch {
-    return null;
+
+    try {
+      return { ok: true, data: JSON.parse(output) };
+    } catch (error) {
+      return {
+        ok: false,
+        error: {
+          type: 'parse',
+          message: `Failed to parse gh output as JSON: ${error.message}`,
+          raw: output.slice(0, 500)
+        }
+      };
+    }
+  } catch (error) {
+    return {
+      ok: false,
+      error: {
+        type: error.killed ? 'timeout' : 'process',
+        message: error.message,
+        exitCode: error.status ?? null,
+        stderr: error.stderr ? String(error.stderr).trim() : ''
+      }
+    };
   }
 }
 
@@ -192,10 +218,18 @@ function scanGitHubState(options = {}) {
 
   const result = {
     available: false,
+    partial: false,
+    errors: [],
     summary: { issueCount: 0, prCount: 0, milestoneCount: 0 },
     issues: [],
     prs: [],
     milestones: [],
+    overdueMilestones: [],
+    pagination: {
+      issues: { requestedLimit: opts.issueLimit, fetchedCount: 0, hasMore: false },
+      prs: { requestedLimit: opts.prLimit, fetchedCount: 0, hasMore: false },
+      milestones: { requestedLimit: opts.milestoneLimit, fetchedCount: 0, hasMore: false }
+    },
     categorized: { bugs: [], features: [], security: [], enhancements: [], other: [] },
     stale: [],
     themes: []
@@ -209,44 +243,74 @@ function scanGitHubState(options = {}) {
   result.available = true;
 
   // Fetch open issues
-  const issues = execGh([
+  const issuesResult = execGhWithResult([
     'issue', 'list',
     '--state', 'open',
     '--json', 'number,title,labels,milestone,createdAt,updatedAt,body',
     '--limit', String(opts.issueLimit)
   ], opts);
 
-  if (issues) {
+  if (issuesResult.ok && Array.isArray(issuesResult.data)) {
+    const issues = issuesResult.data;
     result.issues = issues.map(summarizeIssue);
     result.summary.issueCount = issues.length;
+    result.pagination.issues.fetchedCount = issues.length;
+    result.pagination.issues.hasMore = opts.issueLimit > 0 && issues.length >= opts.issueLimit;
     categorizeIssues(result, issues);
     findStaleItems(result, issues, 90);
     extractThemes(result, issues);
+  } else if (!issuesResult.ok) {
+    result.errors.push({ source: 'issues', ...issuesResult.error });
   }
 
   // Fetch open PRs with files changed
-  const prs = execGh([
+  const prsResult = execGhWithResult([
     'pr', 'list',
     '--state', 'open',
     '--json', 'number,title,labels,isDraft,createdAt,updatedAt,body,files',
     '--limit', String(opts.prLimit)
   ], opts);
 
-  if (prs) {
+  if (prsResult.ok && Array.isArray(prsResult.data)) {
+    const prs = prsResult.data;
     result.prs = prs.map(summarizePR);
     result.summary.prCount = prs.length;
+    result.pagination.prs.fetchedCount = prs.length;
+    result.pagination.prs.hasMore = opts.prLimit > 0 && prs.length >= opts.prLimit;
+  } else if (!prsResult.ok) {
+    result.errors.push({ source: 'prs', ...prsResult.error });
   }
 
   // Fetch milestones
-  const milestones = execGh([
+  const milestonesResult = execGhWithResult([
     'api', 'repos/{owner}/{repo}/milestones',
-    '--jq', '.[].{title,state,due_on,open_issues,closed_issues}'
+    '--paginate',
+    '--slurp'
   ], opts);
 
-  if (milestones) {
-    result.milestones = Array.isArray(milestones) ? milestones : [milestones];
+  if (milestonesResult.ok && Array.isArray(milestonesResult.data)) {
+    const pages = milestonesResult.data;
+    const allMilestones = pages.flatMap(page => Array.isArray(page) ? page : []);
+    const mappedMilestones = allMilestones.map((milestone) => ({
+      title: milestone.title,
+      state: milestone.state,
+      due_on: milestone.due_on,
+      open_issues: milestone.open_issues,
+      closed_issues: milestone.closed_issues
+    }));
+
+    result.pagination.milestones.fetchedCount = mappedMilestones.length;
+    result.pagination.milestones.hasMore = opts.milestoneLimit > 0 && mappedMilestones.length > opts.milestoneLimit;
+    result.milestones = mappedMilestones.slice(0, opts.milestoneLimit);
     result.summary.milestoneCount = result.milestones.length;
     findOverdueMilestones(result);
+  } else if (!milestonesResult.ok) {
+    result.errors.push({ source: 'milestones', ...milestonesResult.error });
+  }
+
+  result.partial = result.errors.length > 0;
+  if (result.partial && !result.error) {
+    result.error = 'Partial GitHub data collected';
   }
 
   return result;

package/lib/perf/benchmark-runner.js

@@ -4,8 +4,9 @@
  * @module lib/perf/benchmark-runner
  */
 
-const { execSync } = require('child_process');
+const { execFileSync } = require('child_process');
 const { validateBaseline } = require('./schemas');
+const { parseCommand, resolveExecutableForPlatform } = require('../utils/command-parser');
 
 const DEFAULT_MIN_DURATION = 60;
 const BINARY_SEARCH_MIN_DURATION = 30;
@@ -55,6 +56,8 @@ function runBenchmark(command, options = {}) {
     throw new Error('Benchmark command must be a non-empty string');
   }
 
+  const parsedCommand = parseCommand(command, 'Benchmark command');
+  const executable = resolveExecutableForPlatform(parsedCommand.executable);
   const normalized = normalizeBenchmarkOptions(options);
   const setDurationEnv = options.setDurationEnv !== false;
   const env = {
@@ -71,18 +74,20 @@ function runBenchmark(command, options = {}) {
   const start = Date.now();
   let output;
   try {
-    output = execSync(command, {
+    output = execFileSync(executable, parsedCommand.args, {
       stdio: 'pipe',
       encoding: 'utf8',
-      env
+      env,
+      windowsHide: true,
+      cwd: options.cwd || process.cwd()
     });
   } catch (error) {
-    const stderr = error.stderr ? error.stderr.toString().trim() : '';
-    const stdout = error.stdout ? error.stdout.toString().trim() : '';
+    const stderr = error.stderr ? String(error.stderr).trim() : '';
+    const stdout = error.stdout ? String(error.stdout).trim() : '';
     const exitCode = error.status ?? 'unknown';
     const details = stderr || stdout || error.message || 'No error details available';
     throw new Error(
-      `Benchmark command failed (exit code ${exitCode}): ${command}\n` +
+      `Benchmark command failed (exit code ${exitCode}): ${parsedCommand.display}\n` +
       `Details: ${details}`
     );
   }

package/lib/perf/investigation-state.js

@@ -14,12 +14,12 @@ const crypto = require('crypto');
 const { getStateDir } = require('../platform/state-dir');
 const { validateInvestigationState, assertValid } = require('./schemas');
 const { writeJsonAtomic, writeFileAtomic } = require('../utils/atomic-write');
+const { isPlainObject, updatesApplied, sleepForRetry } = require('../utils/state-helpers');
 
 const SCHEMA_VERSION = 1;
 const INVESTIGATION_FILE = 'investigation.json';
 const LOG_DIR = 'investigations';
 const BASELINE_DIR = 'baselines';
-
 const PHASES = [
   'setup',
   'baseline',
@@ -196,10 +196,12 @@ function writeInvestigation(state, basePath = process.cwd()) {
  * @returns {object|null}
  */
 function updateInvestigation(updates, basePath = process.cwd()) {
-  const MAX_RETRIES = 3;
+  const MAX_RETRIES = 5;
+  let fallbackState = null;
 
   for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
     const current = readInvestigation(basePath) || {};
+    fallbackState = current;
     const initialVersion = current._version || 0;
     const nextState = { ...current };
 
@@ -209,10 +211,7 @@ function updateInvestigation(updates, basePath = process.cwd()) {
 
       if (value === null) {
         nextState[key] = null;
-      } else if (
-        value && typeof value === 'object' && !Array.isArray(value) &&
-        nextState[key] && typeof nextState[key] === 'object' && !Array.isArray(nextState[key])
-      ) {
+      } else if (isPlainObject(value) && isPlainObject(nextState[key])) {
         nextState[key] = { ...nextState[key], ...value };
       } else {
         nextState[key] = value;
@@ -226,23 +225,23 @@ function updateInvestigation(updates, basePath = process.cwd()) {
 
     // Re-read to verify our write succeeded
     const afterWrite = readInvestigation(basePath);
-    if (afterWrite && afterWrite._version === initialVersion + 1) {
+    if (afterWrite) {
+      fallbackState = afterWrite;
+    }
+    if (afterWrite && afterWrite._version >= initialVersion + 1 && updatesApplied(afterWrite, updates)) {
       return afterWrite; // Success
     }
 
     // Version conflict - retry after brief delay
     if (attempt < MAX_RETRIES - 1) {
       const delay = Math.floor(Math.random() * 50) + 10;
-      const start = Date.now();
-      while (Date.now() - start < delay) {
-        // Busy wait (synchronous delay)
-      }
+      sleepForRetry(delay);
     }
   }
 
   // All retries exhausted
-  console.error('[WARN] updateInvestigation: max retries exceeded, possible version conflict');
-  return readInvestigation(basePath);
+  console.error('[ERROR] updateInvestigation: failed to apply updates after max retries');
+  return readInvestigation(basePath) || fallbackState || { ...updates };
 }
 
 /**

package/lib/perf/profiling-runner.js

@@ -4,8 +4,9 @@
  * @module lib/perf/profiling-runner
  */
 
-const { execSync } = require('child_process');
+const { execFileSync } = require('child_process');
 const profilers = require('./profilers');
+const { parseCommand, resolveExecutableForPlatform } = require('../utils/command-parser');
 
 /**
  * Run a profiling command and return artifacts/hotspots metadata.
@@ -16,6 +17,9 @@ const profilers = require('./profilers');
  */
 function runProfiling(options = {}) {
   const repoPath = options.repoPath || process.cwd();
+  const timeoutMs = Number.isFinite(options.timeoutMs)
+    ? Math.max(1, Math.floor(options.timeoutMs))
+    : null;
   const profiler = profilers.selectProfiler(repoPath);
 
   if (!profiler || typeof profiler.buildCommand !== 'function') {
@@ -27,14 +31,29 @@ function runProfiling(options = {}) {
     output: options.output,
     ...(options.profileOptions || {})
   });
+  const parsedCommand = parseCommand(command, 'Profiling command');
+  const executable = resolveExecutableForPlatform(parsedCommand.executable);
   const env = {
     ...process.env,
     ...(options.env || {})
   };
   try {
-    execSync(command, { stdio: 'pipe', env });
+    const execOptions = {
+      stdio: 'pipe',
+      env,
+      cwd: repoPath,
+      windowsHide: true
+    };
+    if (timeoutMs !== null) {
+      execOptions.timeout = timeoutMs;
+    }
+
+    execFileSync(executable, parsedCommand.args, execOptions);
   } catch (error) {
-    return { ok: false, error: error.message };
+    const stderr = error.stderr ? String(error.stderr).trim() : '';
+    const stdout = error.stdout ? String(error.stdout).trim() : '';
+    const details = stderr || stdout || error.message;
+    return { ok: false, error: `Profiling command failed: ${details}` };
   }
 
   const parsed = typeof profiler.parseOutput === 'function'
@@ -43,7 +62,7 @@ function runProfiling(options = {}) {
 
   const result = {
     tool: profiler.id,
-    command,
+    command: parsedCommand.display,
     hotspots: parsed.hotspots || [],
     artifacts: parsed.artifacts || []
   };

package/lib/repo-map/concurrency.js

@@ -0,0 +1,29 @@
+'use strict';
+
+async function runWithConcurrency(items, limit, worker) {
+  if (!Array.isArray(items) || items.length === 0) {
+    return [];
+  }
+
+  const maxConcurrency = Math.max(1, Math.min(items.length, Math.floor(limit) || 1));
+  const results = new Array(items.length);
+  let cursor = 0;
+
+  async function runWorker() {
+    while (true) {
+      const index = cursor;
+      cursor += 1;
+      if (index >= items.length) {
+        return;
+      }
+      results[index] = await worker(items[index], index);
+    }
+  }
+
+  await Promise.all(Array.from({ length: maxConcurrency }, () => runWorker()));
+  return results;
+}
+
+module.exports = {
+  runWithConcurrency
+};