agentsys 5.0.0 → 5.0.2

package/lib/state/workflow-state.js

@@ -16,11 +16,11 @@ const path = require('path');
 const crypto = require('crypto');
 const { getStateDir } = require('../platform/state-dir');
 const { writeJsonAtomic } = require('../utils/atomic-write');
+const { isPlainObject, updatesApplied, sleepForRetry } = require('../utils/state-helpers');
 
 // File paths
 const TASKS_FILE = 'tasks.json';
 const FLOW_FILE = 'flow.json';
-
 /**
  * Validate and resolve path to prevent path traversal attacks
  * @param {string} basePath - Base directory path
@@ -223,7 +223,7 @@ function writeFlow(flow, worktreePath = process.cwd()) {
  * Uses optimistic locking with version check and retry
  */
 function updateFlow(updates, worktreePath = process.cwd()) {
-  const MAX_RETRIES = 3;
+  const MAX_RETRIES = 5;
 
   for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
     const flow = readFlow(worktreePath) || {};
@@ -238,10 +238,7 @@ function updateFlow(updates, worktreePath = process.cwd()) {
         flow[key] = null;
       }
       // Deep merge if both source and target are non-null objects
-      else if (
-        value && typeof value === 'object' && !Array.isArray(value) &&
-        flow[key] && typeof flow[key] === 'object' && !Array.isArray(flow[key])
-      ) {
+      else if (isPlainObject(value) && isPlainObject(flow[key])) {
         flow[key] = { ...flow[key], ...value };
       }
       // Otherwise direct assignment
@@ -258,24 +255,26 @@ function updateFlow(updates, worktreePath = process.cwd()) {
 
     // Re-read to verify our write succeeded
     const afterWrite = readFlow(worktreePath);
-    if (afterWrite && afterWrite._version === initialVersion + 1) {
+    if (afterWrite && afterWrite._version >= initialVersion + 1 && updatesApplied(afterWrite, updates)) {
       return true; // Success
     }
 
-    // Version conflict - retry after brief delay
+    // Version conflict or overwrite - retry after brief delay
     if (attempt < MAX_RETRIES - 1) {
-      // Small random delay to reduce collision probability
       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] updateFlow: max retries exceeded, possible version conflict');
-  return true; // Return true to not break callers, but log warning
+  // All retries exhausted. One final read can detect if another writer
+  // applied the same updates while we were retrying.
+  const latest = readFlow(worktreePath);
+  if (latest && updatesApplied(latest, updates)) {
+    return true;
+  }
+
+  console.error('[ERROR] updateFlow: failed to apply updates after max retries');
+  return false;
 }
 
 /**
@@ -420,8 +419,8 @@ function completePhase(result = null, worktreePath = process.cwd()) {
     }
   }
 
-  updateFlow(updates, worktreePath);
-  return readFlow(worktreePath);
+  const updated = updateFlow(updates, worktreePath);
+  return updated ? readFlow(worktreePath) : null;
 }
 
 /**
@@ -454,16 +453,17 @@ function failWorkflow(error, worktreePath = process.cwd()) {
 function completeWorkflow(worktreePath = process.cwd()) {
   const flow = readFlow(worktreePath);
 
-  // Clear active task from main project if projectPath is stored
-  if (flow && flow.projectPath) {
-    clearActiveTask(flow.projectPath);
-  }
-
-  return updateFlow({
+  const updated = updateFlow({
     phase: 'complete',
     status: 'completed',
     completedAt: new Date().toISOString()
   }, worktreePath);
+
+  if (updated && flow && flow.projectPath) {
+    clearActiveTask(flow.projectPath);
+  }
+
+  return updated;
 }
 
 /**
@@ -473,16 +473,17 @@ function completeWorkflow(worktreePath = process.cwd()) {
 function abortWorkflow(reason, worktreePath = process.cwd()) {
   const flow = readFlow(worktreePath);
 
-  // Clear active task from main project if projectPath is stored
-  if (flow && flow.projectPath) {
-    clearActiveTask(flow.projectPath);
-  }
-
-  return updateFlow({
+  const updated = updateFlow({
     status: 'aborted',
     abortReason: reason,
     abortedAt: new Date().toISOString()
   }, worktreePath);
+
+  if (updated && flow && flow.projectPath) {
+    clearActiveTask(flow.projectPath);
+  }
+
+  return updated;
 }
 
 // =============================================================================

package/lib/utils/state-helpers.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const { isDeepStrictEqual } = require('util');
+
+const RETRY_SLEEP_STATE = typeof SharedArrayBuffer === 'function' && typeof Atomics === 'object' && typeof Atomics.wait === 'function'
+  ? new Int32Array(new SharedArrayBuffer(4))
+  : null;
+
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function hasUpdatedSubset(target, subset) {
+  if (!isPlainObject(subset)) {
+    return isDeepStrictEqual(target, subset);
+  }
+  if (!isPlainObject(target)) {
+    return false;
+  }
+
+  for (const [key, value] of Object.entries(subset)) {
+    if (!hasUpdatedSubset(target[key], value)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function updatesApplied(state, updates) {
+  if (!state) return false;
+
+  for (const [key, value] of Object.entries(updates || {})) {
+    if (key === '_version') continue;
+    if (!hasUpdatedSubset(state[key], value)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+function sleepForRetry(ms) {
+  if (!Number.isFinite(ms) || ms <= 0) {
+    return;
+  }
+
+  const delayMs = Math.floor(ms);
+  if (RETRY_SLEEP_STATE) {
+    try {
+      Atomics.wait(RETRY_SLEEP_STATE, 0, 0, delayMs);
+    } catch {
+      // Ignore environments where Atomics.wait exists but cannot be used.
+    }
+  }
+}
+
+module.exports = {
+  isPlainObject,
+  updatesApplied,
+  sleepForRetry
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentsys",
-  "version": "5.0.0",
+  "version": "5.0.2",
   "description": "A modular runtime and orchestration system for AI agents - works with Claude Code, OpenCode, and Codex CLI",
   "main": "lib/platform/detect-platform.js",
   "type": "commonjs",
@@ -81,6 +81,7 @@
     "node": ">=18.0.0"
   },
   "dependencies": {
+    "agentsys": "^5.0.0",
     "js-yaml": "^4.1.1"
   },
   "devDependencies": {

package/plugins/agnix/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "agnix",
-  "version": "5.0.0",
+  "version": "5.0.2",
   "description": "Lint agent configurations before they break your workflow. Validates Skills, Hooks, MCP, Memory, Plugins.",
   "author": {
     "name": "Avi Fenesh",

package/plugins/agnix/skills/agnix/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agnix
 description: "Use when user asks to 'lint agent configs', 'validate skills', 'check CLAUDE.md', 'validate hooks', 'lint MCP'. Validates agent configuration files against 155 rules across 10+ AI tools."
-version: 5.0.0
+version: 5.0.2
 argument-hint: "[path] [--fix] [--strict] [--target=claude-code|cursor|codex]"
 ---
 

package/plugins/audit-project/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "audit-project",
-  "version": "5.0.0",
+  "version": "5.0.2",
   "description": "Multi-agent iterative code review until zero issues remain",
   "author": {
     "name": "Avi Fenesh",

package/plugins/audit-project/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/plugins/audit-project/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/plugins/audit-project/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/plugins/audit-project/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/plugins/audit-project/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
+};