@the-open-engine/zeroshot 6.0.0 → 6.0.2

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Covibes
+Copyright (c) 2026 The Open Engine Company
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -503,6 +503,6 @@ The TUI is not included in this release. Use `zeroshot logs -f`, `zeroshot logs
 
 ---
 
-MIT - [Covibes](https://github.com/the-open-engine)
+MIT - [The Open Engine Company](https://github.com/the-open-engine)
 
 Built on [Claude Code](https://claude.com/product/claude-code) by Anthropic.

package/cli/index.js

@@ -67,7 +67,7 @@ const {
   registerDetachedSetupCluster,
 } = require('../lib/detached-startup');
 // Setup wizard removed - use: zeroshot settings set <key> <value>
-const { checkForUpdates } = require('./lib/update-checker');
+const { checkForUpdates, printLegacyDistroNotice } = require('./lib/update-checker');
 const { StatusFooter, AGENT_STATE, ACTIVE_STATES } = require('../src/status-footer');
 
 // =============================================================================
@@ -5387,13 +5387,15 @@ function printMessage(msg, showClusterId = false, watchMode = false, isActive =
 
 // Main async entry point
 async function main() {
-  const isQuiet =
-    process.argv.includes('-q') ||
-    process.argv.includes('--quiet') ||
-    process.env.NODE_ENV === 'test';
+  const isTest = process.env.NODE_ENV === 'test';
+  const isQuiet = process.argv.includes('-q') || process.argv.includes('--quiet') || isTest;
+
+  printLegacyDistroNotice();
 
   // Check for updates (non-blocking if offline)
-  await checkForUpdates({ quiet: isQuiet });
+  if (!isTest) {
+    await checkForUpdates({ quiet: isQuiet });
+  }
 
   let args = process.argv.slice(2);
 

package/cli/lib/update-checker.js

@@ -9,10 +9,16 @@
  */
 
 const https = require('https');
-const { spawn } = require('child_process');
+const childProcess = require('child_process');
+const fs = require('fs');
+const path = require('path');
 const readline = require('readline');
 const { loadSettings, saveSettings } = require('../../lib/settings');
 
+const NEW_PACKAGE_NAME = '@the-open-engine/zeroshot';
+const LEGACY_PACKAGE_NAME = '@covibes/zeroshot';
+const NEW_PACKAGE_SPEC = `${NEW_PACKAGE_NAME}@latest`;
+
 // 24 hours in milliseconds
 const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
 
@@ -20,15 +26,177 @@ const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
 const FETCH_TIMEOUT_MS = 5000;
 
 // npm registry URL
-const REGISTRY_URL = 'https://registry.npmjs.org/@the-open-engine/zeroshot/latest';
+const REGISTRY_URL = `https://registry.npmjs.org/${NEW_PACKAGE_NAME}/latest`;
+
+function getPackageMetadata() {
+  return require('../../package.json');
+}
+
+function getCurrentPackageName() {
+  return getPackageMetadata().name || NEW_PACKAGE_NAME;
+}
 
 /**
  * Get current package version
  * @returns {string}
  */
 function getCurrentVersion() {
-  const pkg = require('../../package.json');
-  return pkg.version;
+  return getPackageMetadata().version;
+}
+
+function isLegacyDistro(packageName = getCurrentPackageName()) {
+  return packageName === LEGACY_PACKAGE_NAME;
+}
+
+function printLegacyDistroNotice(packageName = getCurrentPackageName()) {
+  if (!isLegacyDistro(packageName)) {
+    return false;
+  }
+
+  console.error(
+    `\n⚠️  ${LEGACY_PACKAGE_NAME} has moved to ${NEW_PACKAGE_NAME}. ` +
+      'Run `zeroshot update` to switch this installation.\n'
+  );
+  return true;
+}
+
+function getPackageRoot() {
+  return path.dirname(require.resolve('../../package.json'));
+}
+
+function hasPathSuffix(parts, suffix) {
+  if (suffix.length > parts.length) {
+    return false;
+  }
+
+  const start = parts.length - suffix.length;
+  return suffix.every((part, index) => parts[start + index] === part);
+}
+
+function joinPathParts(parts) {
+  const joined = parts.join(path.sep);
+  return joined === '' ? path.parse(process.cwd()).root : joined;
+}
+
+function deriveInstallPrefixFromPackageRoot(packageRoot, packageName) {
+  const parts = path.resolve(packageRoot).split(path.sep);
+  const packageParts = packageName.split('/');
+
+  if (!hasPathSuffix(parts, packageParts)) {
+    return null;
+  }
+
+  const nodeModulesIndex = parts.length - packageParts.length - 1;
+  if (nodeModulesIndex < 0 || parts[nodeModulesIndex] !== 'node_modules') {
+    return null;
+  }
+
+  if (parts[nodeModulesIndex - 1] === 'lib') {
+    return joinPathParts(parts.slice(0, nodeModulesIndex - 1));
+  }
+
+  return joinPathParts(parts.slice(0, nodeModulesIndex));
+}
+
+function resolveNpmCommand(installPrefix = null) {
+  const npmName = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+  const candidates = [];
+
+  if (installPrefix) {
+    candidates.push(path.join(installPrefix, 'bin', npmName));
+  }
+
+  candidates.push(path.join(path.dirname(process.execPath), npmName));
+
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+
+  return npmName;
+}
+
+function getNpmConfiguredPrefix(npmCommand = resolveNpmCommand()) {
+  return childProcess
+    .execFileSync(npmCommand, ['config', 'get', 'prefix'], {
+      encoding: 'utf8',
+    })
+    .trim();
+}
+
+function getInstallPrefix(options = {}) {
+  if (options.installPrefix) {
+    return options.installPrefix;
+  }
+
+  const packageName = options.packageName || getCurrentPackageName();
+  const packageRoot = options.packageRoot || getPackageRoot();
+  const derivedPrefix = deriveInstallPrefixFromPackageRoot(packageRoot, packageName);
+
+  if (derivedPrefix) {
+    return derivedPrefix;
+  }
+
+  return getNpmConfiguredPrefix(options.npmCommand);
+}
+
+function getGlobalModulesDir(installPrefix) {
+  const unixGlobalModulesDir = path.join(installPrefix, 'lib', 'node_modules');
+  if (fs.existsSync(unixGlobalModulesDir)) {
+    return unixGlobalModulesDir;
+  }
+
+  return path.join(installPrefix, 'node_modules');
+}
+
+function shellQuote(value) {
+  if (/^[A-Za-z0-9_./:@+-]+$/.test(value)) {
+    return value;
+  }
+
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+
+function buildManualInstallCommand(installPrefix = null, useSudo = false) {
+  const command = [
+    useSudo ? 'sudo' : null,
+    'npm',
+    'install',
+    '-g',
+    installPrefix ? '--prefix' : null,
+    installPrefix ? shellQuote(installPrefix) : null,
+    NEW_PACKAGE_SPEC,
+  ].filter(Boolean);
+
+  return command.join(' ');
+}
+
+function getUpdateTarget(options = {}) {
+  const packageName = options.packageName || getCurrentPackageName();
+  const legacy = isLegacyDistro(packageName);
+  const installPrefix = getInstallPrefix(options);
+  const npmCommand = options.npmCommand || resolveNpmCommand(installPrefix);
+
+  return {
+    packageName,
+    legacy,
+    installPrefix,
+    npmCommand,
+    globalModulesDir: getGlobalModulesDir(installPrefix),
+  };
+}
+
+function buildInstallArgs(updateTarget) {
+  const args = ['install', '-g', '--prefix', updateTarget.installPrefix];
+
+  if (updateTarget.legacy) {
+    // npm refuses to replace the legacy package's `zeroshot` bin without this.
+    args.push('--force');
+  }
+
+  args.push(NEW_PACKAGE_SPEC);
+  return args;
 }
 
 /**
@@ -119,17 +287,10 @@ function promptForUpdate(currentVersion, latestVersion) {
  * Check if we have write permission to npm global directory
  * @returns {boolean} True if we can write to npm global prefix
  */
-function canWriteToNpmGlobal() {
-  const { execSync } = require('child_process');
-  const fs = require('fs');
-
+function canWriteToNpmGlobal(options = {}) {
   try {
-    // Get npm global prefix (e.g., /usr/lib or /home/user/.nvm/versions/node/...)
-    const prefix = execSync('npm config get prefix', { encoding: 'utf8' }).trim();
-    const globalModulesDir = require('path').join(prefix, 'lib', 'node_modules');
-
-    // Check if directory exists and is writable
-    fs.accessSync(globalModulesDir, fs.constants.W_OK);
+    const updateTarget = getUpdateTarget(options);
+    fs.accessSync(updateTarget.globalModulesDir, fs.constants.W_OK);
     return true;
   } catch {
     return false;
@@ -140,22 +301,32 @@ function canWriteToNpmGlobal() {
  * Run npm install to update the package
  * @returns {Promise<boolean>} True if update succeeded
  */
-function runUpdate() {
+function runUpdate(options = {}) {
   return new Promise((resolve) => {
+    let updateTarget;
+    try {
+      updateTarget = getUpdateTarget(options);
+    } catch {
+      console.log('❌ Update failed. Try manually:');
+      console.log(`   ${buildManualInstallCommand()}\n`);
+      resolve(false);
+      return;
+    }
+
     // Check permissions BEFORE attempting update
-    if (!canWriteToNpmGlobal()) {
+    if (!canWriteToNpmGlobal(options)) {
       console.log('\n⚠️  Cannot auto-update: no write permission to npm global directory.');
       console.log('   Run manually with sudo:');
-      console.log('   sudo npm install -g @the-open-engine/zeroshot@latest\n');
+      console.log(`   ${buildManualInstallCommand(updateTarget.installPrefix, true)}\n`);
       resolve(false);
       return;
     }
 
     console.log('\n📥 Installing update...');
 
-    const proc = spawn('npm', ['install', '-g', '@the-open-engine/zeroshot@latest'], {
+    const proc = childProcess.spawn(updateTarget.npmCommand, buildInstallArgs(updateTarget), {
       stdio: 'inherit',
-      shell: true,
+      shell: false,
     });
 
     proc.on('close', (code) => {
@@ -165,14 +336,14 @@ function runUpdate() {
         resolve(true);
       } else {
         console.log('❌ Update failed. Try manually:');
-        console.log('   sudo npm install -g @the-open-engine/zeroshot@latest\n');
+        console.log(`   ${buildManualInstallCommand(updateTarget.installPrefix, true)}\n`);
         resolve(false);
       }
     });
 
     proc.on('error', () => {
       console.log('❌ Update failed. Try manually:');
-      console.log('   sudo npm install -g @the-open-engine/zeroshot@latest\n');
+      console.log(`   ${buildManualInstallCommand(updateTarget.installPrefix, true)}\n`);
       resolve(false);
     });
   });
@@ -246,9 +417,9 @@ async function checkForUpdates(options = {}) {
   if (options.quiet) {
     console.log(`📦 Update available: ${currentVersion} → ${latestVersion}`);
     if (hasWriteAccess) {
-      console.log('   Run: npm install -g @the-open-engine/zeroshot@latest\n');
+      console.log(`   Run: ${buildManualInstallCommand(getInstallPrefix(), false)}\n`);
     } else {
-      console.log('   Run: sudo npm install -g @the-open-engine/zeroshot@latest\n');
+      console.log(`   Run: ${buildManualInstallCommand(getInstallPrefix(), true)}\n`);
     }
     return;
   }
@@ -257,7 +428,7 @@ async function checkForUpdates(options = {}) {
   // (they'd say yes then get an error, which is frustrating UX)
   if (!hasWriteAccess) {
     console.log(`\n📦 Update available: ${currentVersion} → ${latestVersion}`);
-    console.log('   Run: sudo npm install -g @the-open-engine/zeroshot@latest\n');
+    console.log(`   Run: ${buildManualInstallCommand(getInstallPrefix(), true)}\n`);
     return;
   }
 
@@ -271,7 +442,17 @@ async function checkForUpdates(options = {}) {
 module.exports = {
   checkForUpdates,
   // Exported for testing and CLI update command
+  NEW_PACKAGE_NAME,
+  LEGACY_PACKAGE_NAME,
   getCurrentVersion,
+  getCurrentPackageName,
+  isLegacyDistro,
+  printLegacyDistroNotice,
+  deriveInstallPrefixFromPackageRoot,
+  getInstallPrefix,
+  resolveNpmCommand,
+  getUpdateTarget,
+  buildInstallArgs,
   isNewerVersion,
   fetchLatestVersion,
   runUpdate,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@the-open-engine/zeroshot",
-  "version": "6.0.0",
+  "version": "6.0.2",
   "description": "Multi-agent orchestration engine for Claude, Codex, and Gemini",
   "main": "src/orchestrator.js",
   "bin": {

package/src/config-validator.js

@@ -17,6 +17,13 @@ const { getProvider } = require('./providers');
 const { CAPABILITIES } = require('./providers/capabilities');
 const { GUIDANCE_TOPICS } = require('./guidance-topics');
 
+const HOOK_ACTION_TOPIC_CONTRACTS = Object.freeze({
+  verify_pull_request: Object.freeze([
+    { topic: 'CLUSTER_COMPLETE', keys: null },
+    { topic: 'PUSH_BLOCKED', keys: null },
+  ]),
+});
+
 /**
  * Check if config is a conductor-bootstrap style config
  * Conductor configs dynamically spawn agents via CLUSTER_OPERATIONS
@@ -288,6 +295,25 @@ function ensureTopicList(map, topic) {
   return map.get(topic);
 }
 
+function getHookActionTopicContracts(hook) {
+  if (!hook?.action) {
+    return [];
+  }
+  return HOOK_ACTION_TOPIC_CONTRACTS[hook.action] || [];
+}
+
+function recordOutputTopic(agent, topic, topicProducers, agentOutputTopics, producerId = agent.id) {
+  const producers = ensureTopicList(topicProducers, topic);
+  if (!producers.includes(producerId)) {
+    producers.push(producerId);
+  }
+
+  const outputs = agentOutputTopics.get(agent.id);
+  if (!outputs.includes(topic)) {
+    outputs.push(topic);
+  }
+}
+
 function recordAgentTriggers(agent, topicConsumers, agentInputTopics) {
   for (const trigger of agent.triggers || []) {
     const topic = trigger.topic;
@@ -321,16 +347,19 @@ function extractDynamicTopicsFromScript(script, ctx) {
 }
 
 function recordAgentOutputs(agent, topicProducers, agentOutputTopics) {
+  const hook = agent.hooks?.onComplete;
   const outputTopic = agent.hooks?.onComplete?.config?.topic;
   if (outputTopic) {
-    ensureTopicList(topicProducers, outputTopic).push(agent.id);
-    agentOutputTopics.get(agent.id).push(outputTopic);
+    recordOutputTopic(agent, outputTopic, topicProducers, agentOutputTopics);
   }
 
   const ctx = { outputTopic, agentId: agent.id, topicProducers, agentOutputTopics };
-  const hook = agent.hooks?.onComplete;
   extractDynamicTopicsFromScript(hook?.logic?.script, ctx);
   extractDynamicTopicsFromScript(hook?.transform?.script, ctx);
+
+  for (const contract of getHookActionTopicContracts(hook)) {
+    recordOutputTopic(agent, contract.topic, topicProducers, agentOutputTopics);
+  }
 }
 
 function buildMessageFlowGraph(config) {
@@ -683,6 +712,13 @@ function collectTopicContracts(config) {
         addContract(topic, { agentId: agent.id, keys: null });
       }
     }
+
+    for (const contract of getHookActionTopicContracts(hook)) {
+      addContract(contract.topic, {
+        agentId: agent.id,
+        keys: contract.keys instanceof Set ? new Set(contract.keys) : contract.keys,
+      });
+    }
   }
 
   return contracts;