nothumanallowed 17.0.0 → 17.0.2

package/README.md

@@ -27,7 +27,7 @@ nha run "Design a Kubernetes deployment for a 10K RPS API"
 nha ui
 ```
 
-**Do I need a local model?** No. You need one LLM, and you choose which: an API key of a cloud provider, or a model running on your machine. A local model is the option that needs no key and sends nothing out. The hosted free tier (Liara) that earlier versions used by default is currently offline: set a provider before the first prompt.
+**Do I need a local model?** No. You need one LLM, and you choose which: an API key of a cloud provider, or a model running on your machine. A local model is the option that needs no key and sends nothing out. Earlier versions started on a hosted free model (Liara). It is offline and no longer the default: a new install has no provider until you set one.
 
 ## Studio — Visual Agentic Workflows
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothumanallowed",
-  "version": "17.0.0",
+  "version": "17.0.2",
   "description": "Local AI assistant: 80 tools (Gmail, Calendar, Drive, GitHub, Slack, browser, code, files), 38 agents, multi-agent deliberation that runs entirely on your machine (Legion X), visual workflows (Studio, AWF, WebCraft). Install with `npm i -g nothumanallowed`, run with `nha ui`. Bring your own LLM: an API key or a local model (Ollama, any OpenAI-compatible endpoint). Your data stays on your PC — OAuth tokens local, no cloud. Open-source MIT.",
   "type": "module",
   "bin": {

package/src/cli.mjs

@@ -582,7 +582,7 @@ function cmdConfig(args) {
   console.log(`\n  ${BOLD}NHA Configuration${NC}  ${D}(~/.nha/config.json)${NC}\n`);
 
   console.log(`  ${C}LLM${NC}`);
-  console.log(`    Provider:     ${W}${config.llm.provider}${NC}`);
+  console.log(`    Provider:     ${config.llm.provider ? W + config.llm.provider : R + '(not set)'}${NC}`);
   console.log(`    API Key:      ${config.llm.apiKey ? G + config.llm.apiKey.slice(0, 12) + '...' + NC : R + '(not set)' + NC}`);
   if (config.llm.openaiKey) console.log(`    OpenAI Key:   ${G}${config.llm.openaiKey.slice(0, 12)}...${NC}`);
   if (config.llm.geminiKey) console.log(`    Gemini Key:   ${G}${config.llm.geminiKey.slice(0, 12)}...${NC}`);

package/src/commands/ask.mjs

@@ -10,7 +10,7 @@ import fs from 'fs';
 import path from 'path';
 import { loadConfig } from '../config.mjs';
 import { AGENTS_DIR, AGENTS } from '../constants.mjs';
-import { getProviderCall, getApiKey, parseAgentFile } from '../services/llm.mjs';
+import { getProviderCall, getApiKey, hostedOfflineError, parseAgentFile } from '../services/llm.mjs';
 import { fail, info, ok, C, G, Y, D, W, BOLD, NC, M } from '../ui.mjs';
 
 export async function cmdAsk(args) {
@@ -108,15 +108,8 @@ export async function cmdAsk(args) {
       let response = '';
 
       if (provider === 'nha') {
-        // NHA Free tier — Liara Vision
-        const res = await fetch('https://nothumanallowed.com/api/v1/liara/vision', {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ image_base64: base64, prompt: imagePrompt }),
-        });
-        if (!res.ok) throw new Error(`Liara Vision ${res.status}`);
-        const data = await res.json();
-        response = data.description || data.text || JSON.stringify(data);
+        // The hosted model no longer reads images: nothing is sent to it.
+        throw hostedOfflineError();
       } else if (provider === 'anthropic') {
         const res = await fetch('https://api.anthropic.com/v1/messages', {
           method: 'POST',

package/src/config.mjs

@@ -11,7 +11,10 @@ const LEGACY_PIF = path.join(os.homedir(), '.pif-agent.json');
 const DEFAULT_CONFIG = {
   version: 1,
   llm: {
-    provider: 'nha',
+    // Empty = not chosen yet. It used to be 'nha', the hosted free model,
+    // which is offline: a new install must not start on a provider that
+    // cannot answer. A provider saved by an existing user is left as it is.
+    provider: '',
     apiKey: '',
     openaiKey: '',
     geminiKey: '',

package/src/constants.mjs

@@ -5,7 +5,7 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-export const VERSION = '17.0.0';
+export const VERSION = '17.0.2';
 export const BASE_URL = 'https://nothumanallowed.com/cli';
 export const API_BASE = 'https://nothumanallowed.com/api/v1';
 

package/src/legion/legion-x.mjs

@@ -6061,9 +6061,30 @@ var GETH_DOMAIN_AFFINITY = {
  * A replacement comes from the preferred categories, then the allowed ones,
  * and is never an agent already in the list. With no replacement left the
  * original stays: too few agents is worse than one out of place.
- * LOGOS always passes (domain-agnostic reasoner). A general or uncertain
- * domain (confidence below 0.3) changes nothing.
+ * The domain-agnostic agents always pass. A general or uncertain domain
+ * (confidence below 0.3) changes nothing.
  */
+// Their work applies to any subject, whatever category the catalog files them
+// under: LOGOS checks the reasoning, VERITAS checks the claims.
+var GETH_DOMAIN_AGNOSTIC_AGENTS = ['LOGOS', 'VERITAS'];
+
+var GETH_DOMAIN_TIER_PROHIBITED = 3;
+
+/**
+ * How well an agent fits the question's domain: 0 preferred category,
+ * 1 allowed, 2 neither listed, 3 prohibited. A general or uncertain domain
+ * (confidence below 0.3) ranks every agent the same, and the domain-agnostic
+ * agents are never prohibited.
+ */
+function gethDomainTier(agentName, category, domain) {
+  if (!domain || domain.family === 'general' || domain.confidence < 0.3) return 0;
+  var affinity = GETH_DOMAIN_AFFINITY[domain.family] || GETH_DOMAIN_AFFINITY.general;
+  if (affinity.preferred.indexOf(category) !== -1) return 0;
+  if (affinity.allowed.indexOf(category) !== -1) return 1;
+  if (affinity.prohibited.indexOf(category) === -1) return 2;
+  return GETH_DOMAIN_AGNOSTIC_AGENTS.indexOf(String(agentName).toUpperCase()) !== -1 ? 1 : GETH_DOMAIN_TIER_PROHIBITED;
+}
+
 function gethValidateAgentDomainAffinity(agents, domain, available) {
   var unchanged = agents.map(function(a) { return { name: a.name, category: a.category }; });
   if (domain.family === 'general' || domain.confidence < 0.3) return unchanged;
@@ -6085,7 +6106,7 @@ function gethValidateAgentDomainAffinity(agents, domain, available) {
   }
 
   return agents.map(function(agent) {
-    if (agent.name.toUpperCase() === 'LOGOS' || affinity.prohibited.indexOf(agent.category) === -1) {
+    if (GETH_DOMAIN_AGNOSTIC_AGENTS.indexOf(agent.name.toUpperCase()) !== -1 || affinity.prohibited.indexOf(agent.category) === -1) {
       return { name: agent.name, category: agent.category };
     }
     var replacement = findReplacement();
@@ -7300,21 +7321,32 @@ class LocalGethOrchestrator {
   /**
    * One orchestrator call with provider fallback. Tries the preferred provider,
    * then the others in order; throws the last error when all of them fail.
+   *
+   * `usable(text)` is optional: when it returns false the answer cannot be
+   * read (a model that chats instead of following the format), and the next
+   * configured provider is asked. If none does better, the first unreadable
+   * answer is returned and the caller decides what to make of it.
    */
-  async orchestratorChat(session, systemPrompt, userMessage, maxTokens, agentTag) {
+  async orchestratorChat(session, systemPrompt, userMessage, maxTokens, agentTag, usable) {
     var preferred = this.pickOrchestratorProvider(session);
     var order = [preferred].concat(session.providers.filter(function(p) { return p !== preferred; }));
     var lastErr = null;
+    var unreadable = null;
     for (var i = 0; i < order.length; i++) {
       try {
         var text = await this.llm.chatWithProvider(order[i], systemPrompt, userMessage, {
           maxTokens: maxTokens, agentTag: agentTag,
         });
+        if (usable && !usable(text)) {
+          if (!unreadable) unreadable = { text: text, provider: order[i] };
+          continue;
+        }
         return { text: text, provider: order[i] };
       } catch (err) {
         lastErr = err;
       }
     }
+    if (unreadable) return unreadable;
     throw lastErr || new Error('No provider available for the orchestrator');
   }
 
@@ -7882,11 +7914,22 @@ class LocalGethOrchestrator {
       assignments.forEach(function(a) { assigned[a.agentName] = true; });
       var categoriesInUse = {};
       assignments.forEach(function(a) { categoriesInUse[a.category] = true; });
+      // The agents added here answer the same question as the ones PROMETHEUS
+      // chose, so the same domain rule applies: an agent the guardrail just
+      // removed, or one of a category prohibited for the domain, is not
+      // brought back in by the top-up. Fitting categories come first.
+      var topUpDomain = session.domain || gethClassifyDomain(session.prompt);
+      var removedByGuardrail = {};
+      (session.domainReplacements || []).forEach(function(r) { removedByGuardrail[String(r.from).toUpperCase()] = true; });
       var candidates = this.getCatalog()
-        .filter(function(a) { return !assigned[a.agentName] && PARLIAMENT_AGENT_NAMES.indexOf(a.agentName) === -1; });
+        .filter(function(a) { return !assigned[a.agentName] && PARLIAMENT_AGENT_NAMES.indexOf(a.agentName) === -1; })
+        .filter(function(a) { return !removedByGuardrail[a.agentName.toUpperCase()]; })
+        .map(function(a) { return { agent: a, tier: gethDomainTier(a.agentName, a.category, topUpDomain) }; })
+        .filter(function(c) { return c.tier < GETH_DOMAIN_TIER_PROHIBITED; });
       candidates = gethShuffle(candidates).sort(function(x, y) {
-        return (categoriesInUse[x.category] ? 1 : 0) - (categoriesInUse[y.category] ? 1 : 0);
-      });
+        if (x.tier !== y.tier) return x.tier - y.tier;
+        return (categoriesInUse[x.agent.category] ? 1 : 0) - (categoriesInUse[y.agent.category] ? 1 : 0);
+      }).map(function(c) { return c.agent; });
       for (var ci = 0; ci < candidates.length && assignments.length < providerFloor; ci++) {
         assignments.push({
           agentName: candidates[ci].agentName,
@@ -8465,16 +8508,23 @@ class LocalGethOrchestrator {
       'At most 12 claims, the most consequential first. If nothing deserves a warning, return an empty list.\n\n' +
       'Respond ONLY with JSON: {"claims":[{"claim":"the claim, quoted or closely paraphrased","agents":["AGENT"],"status":"contradicted|doubtful|unsupported","note":"why, in one sentence"}]}';
 
+    // A list of claims, even an empty one, or null when the answer is not one.
+    function readClaims(text) {
+      var json = extractJSON(text);
+      if (json && Array.isArray(json.claims)) return json;
+      // Cut off by the token limit: the claims already written still count.
+      var salvagedClaims = gethSalvageArrayObjects(text, 'claims');
+      return salvagedClaims.length > 0 ? { claims: salvagedClaims } : null;
+    }
+
     try {
+      // Any of the user's providers can do this: one that cannot answer in
+      // the format is followed by the next.
       var result = await this.orchestratorChat(session, systemPrompt,
-        'Question: ' + session.prompt + '\n\nAgents\' final positions:\n\n' + body, 4096, '_fact_check');
-      var parsed = extractJSON(result.text);
-      if (!parsed || !Array.isArray(parsed.claims)) {
-        // Cut off by the token limit: the claims already written still count.
-        var salvagedClaims = gethSalvageArrayObjects(result.text, 'claims');
-        if (salvagedClaims.length === 0) return null;
-        parsed = { claims: salvagedClaims };
-      }
+        'Question: ' + session.prompt + '\n\nAgents\' final positions:\n\n' + body, 4096, '_fact_check',
+        function(text) { return readClaims(text) !== null; });
+      var parsed = readClaims(result.text);
+      if (!parsed) return null;
       var allowed = ['contradicted', 'doubtful', 'unsupported'];
       var claims = [];
       for (var i = 0; i < parsed.claims.length && claims.length < 12; i++) {
@@ -8792,7 +8842,10 @@ class LocalGethOrchestrator {
 
     try {
       // 1024 tokens cut the list of omissions short on real deliberations.
-      var result = await this.orchestratorChat(session, systemPrompt, userMessage, 4096, 'ATHENA');
+      var result = await this.orchestratorChat(session, systemPrompt, userMessage, 4096, 'ATHENA', function(text) {
+        var json = extractJSON(text);
+        return !!(json && (json.verdict === 'PASS' || json.verdict === 'FLAG')) || gethSalvageAthenaVerdict(text) !== null;
+      });
       var parsed = extractJSON(result.text);
       var truncated = false;
       if (!parsed || (parsed.verdict !== 'PASS' && parsed.verdict !== 'FLAG')) {

package/src/services/llm.mjs

@@ -1234,22 +1234,8 @@ export async function callLLMVision(config, systemPrompt, userMessage, media) {
   const provider = config.llm.provider || 'anthropic';
   const model = config.llm.model || null;
 
-  // NHA Free tier — use Liara Vision (no API key needed)
-  if (provider === 'nha') {
-    const { base64, mimeType } = media;
-    if (!base64) throw new Error('media.base64 required for vision');
-    const res = await fetch('https://nothumanallowed.com/api/v1/liara/vision', {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json', 'x-nha-client': 'cli' },
-      body: JSON.stringify({ image_base64: base64, prompt: userMessage || 'Describe this image in detail.' }),
-    });
-    if (!res.ok) {
-      const err = await res.text().catch(() => '');
-      throw new Error(`Liara Vision ${res.status}: ${err.slice(0, 200)}`);
-    }
-    const data = await res.json();
-    return data.description || data.text || JSON.stringify(data);
-  }
+  // The hosted model no longer reads images: nothing is sent to it.
+  if (provider === 'nha') throw hostedOfflineError();
 
   const apiKey = getApiKey(config, provider);
   if (!apiKey) throw new Error(`No API key for ${provider}. Vision requires Claude, GPT-4 or Gemini with your own key (nha config set key YOUR_KEY).`);