@neuroverseos/governance 0.3.3 → 0.3.4

package/dist/{derive-FJZVIPUZ.js → derive-LMDUTXDD.js}

@@ -2,11 +2,12 @@ import {
   DeriveInputError,
   DeriveProviderError,
   deriveWorld
-} from "./chunk-6S5CFQXY.js";
+} from "./chunk-YEKMVDWK.js";
 import {
   DERIVE_EXIT_CODES
-} from "./chunk-Q6O7ZLO2.js";
+} from "./chunk-FMSTRBBS.js";
 import "./chunk-OT6PXH54.js";
+import "./chunk-INWQHLPS.js";
 import "./chunk-7P3S7MAY.js";
 import "./chunk-EMQDLDAF.js";
 import "./chunk-PVTQQS3Y.js";

package/dist/{guard-AJCCGZMF.js → guard-AEEJNWLD.js}

@@ -2,8 +2,10 @@ import {
   readStdin
 } from "./chunk-BQZMOEML.js";
 import {
-  GUARD_EXIT_CODES
-} from "./chunk-MH7BT4VH.js";
+  GUARD_EXIT_CODES,
+  evaluateGuardWithAI
+} from "./chunk-VXHSMA3I.js";
+import "./chunk-INWQHLPS.js";
 import {
   describeActiveWorld,
   resolveWorldPath
@@ -22,12 +24,15 @@ function parseArgs(argv) {
   let worldPath = "";
   let trace = false;
   let level;
+  let aiClassify = false;
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
     if (arg === "--world" && i + 1 < argv.length) {
       worldPath = argv[++i];
     } else if (arg === "--trace") {
       trace = true;
+    } else if (arg === "--ai-classify") {
+      aiClassify = true;
     } else if (arg === "--level" && i + 1 < argv.length) {
       const val = argv[++i];
       if (val === "basic" || val === "standard" || val === "strict") {
@@ -37,7 +42,7 @@ function parseArgs(argv) {
       }
     }
   }
-  return { worldPath, trace, level };
+  return { worldPath, trace, level, aiClassify };
 }
 async function main(argv = process.argv.slice(2)) {
   try {
@@ -76,8 +81,27 @@ async function main(argv = process.argv.slice(2)) {
       process.exit(GUARD_EXIT_CODES.ERROR);
     }
     const world = await loadWorld(worldPath);
-    const options = { trace: args.trace, level: args.level };
-    const verdict = evaluateGuard(event, world, options);
+    let verdict;
+    if (args.aiClassify) {
+      const aiConfig = resolveAIConfig();
+      if (!aiConfig) {
+        const errorResult = {
+          error: "AI classification requires an API key. Set NEUROVERSE_AI_API_KEY and optionally NEUROVERSE_AI_MODEL, NEUROVERSE_AI_ENDPOINT."
+        };
+        process.stdout.write(JSON.stringify(errorResult, null, 2) + "\n");
+        process.exit(GUARD_EXIT_CODES.ERROR);
+      }
+      process.stderr.write("AI intent classification enabled\n");
+      verdict = await evaluateGuardWithAI(event, world, {
+        trace: args.trace,
+        level: args.level,
+        ai: aiConfig,
+        contentFields: event.contentFields
+      });
+    } else {
+      const options = { trace: args.trace, level: args.level };
+      verdict = evaluateGuard(event, world, options);
+    }
     process.stdout.write(JSON.stringify(verdict, null, 2) + "\n");
     const exitCode = GUARD_EXIT_CODES[verdict.status];
     process.exit(exitCode);
@@ -87,6 +111,16 @@ async function main(argv = process.argv.slice(2)) {
     process.exit(GUARD_EXIT_CODES.ERROR);
   }
 }
+function resolveAIConfig() {
+  const apiKey = process.env.NEUROVERSE_AI_API_KEY;
+  if (!apiKey) return null;
+  return {
+    provider: "openai",
+    model: process.env.NEUROVERSE_AI_MODEL ?? "gpt-4o-mini",
+    apiKey,
+    endpoint: process.env.NEUROVERSE_AI_ENDPOINT ?? null
+  };
+}
 export {
   main
 };

package/dist/{guard-contract-DqFcTScd.d.cts → guard-contract-B7lplwm9.d.cts}

@@ -536,6 +536,22 @@ interface GuardEvent {
     args?: Record<string, unknown>;
     /** Environment context (e.g. "development", "production") */
     environment?: string;
+    /**
+     * Structured content fields for AI intent classification.
+     *
+     * When present, enables separation of customer input from AI output
+     * so the guard can distinguish "customer demands escalation" from
+     * "AI politely says 'I am escalating your request'".
+     *
+     * Used by evaluateGuardWithAI() — ignored by the sync evaluateGuard().
+     */
+    contentFields?: {
+        customer_input?: string;
+        draft_reply?: string;
+        tool?: string;
+        context?: string;
+        raw?: string;
+    };
 }
 type GuardStatus = 'ALLOW' | 'BLOCK' | 'PAUSE' | 'MODIFY' | 'PENALIZE' | 'REWARD' | 'NEUTRAL';
 /**

package/dist/{guard-contract-DqFcTScd.d.ts → guard-contract-B7lplwm9.d.ts}

@@ -536,6 +536,22 @@ interface GuardEvent {
     args?: Record<string, unknown>;
     /** Environment context (e.g. "development", "production") */
     environment?: string;
+    /**
+     * Structured content fields for AI intent classification.
+     *
+     * When present, enables separation of customer input from AI output
+     * so the guard can distinguish "customer demands escalation" from
+     * "AI politely says 'I am escalating your request'".
+     *
+     * Used by evaluateGuardWithAI() — ignored by the sync evaluateGuard().
+     */
+    contentFields?: {
+        customer_input?: string;
+        draft_reply?: string;
+        tool?: string;
+        context?: string;
+        raw?: string;
+    };
 }
 type GuardStatus = 'ALLOW' | 'BLOCK' | 'PAUSE' | 'MODIFY' | 'PENALIZE' | 'REWARD' | 'NEUTRAL';
 /**

package/dist/index.cjs

@@ -857,6 +857,7 @@ __export(index_exports, {
   buildPlanCheck: () => buildPlanCheck,
   classifyAdaptation: () => classifyAdaptation,
   classifyIntent: () => classifyIntent,
+  classifyIntentWithAI: () => classifyIntentWithAI,
   createAgentState: () => createAgentState,
   createGovernanceEngine: () => createGovernanceEngine,
   createGovernor: () => createGovernor,
@@ -866,9 +867,11 @@ __export(index_exports, {
   emitWorldDefinition: () => emitWorldDefinition,
   evaluateCondition: () => evaluateCondition,
   evaluateGuard: () => evaluateGuard,
+  evaluateGuardWithAI: () => evaluateGuardWithAI,
   evaluatePlan: () => evaluatePlan,
   eventToAllowlistKey: () => eventToAllowlistKey,
   explainWorld: () => explainWorld,
+  extractContentFields: () => extractContentFields,
   extractWorldMarkdown: () => extractWorldMarkdown,
   formatVerdict: () => formatVerdict,
   formatVerdictOneLine: () => formatVerdictOneLine,
@@ -1975,6 +1978,191 @@ function buildVerdict(status, reason, ruleId, warning, world, level, invariantCh
   return verdict;
 }
 
+// src/providers/ai-provider.ts
+var ChatCompletionsProvider = class {
+  model;
+  apiKey;
+  endpoint;
+  constructor(config) {
+    this.model = config.model;
+    this.apiKey = config.apiKey;
+    this.endpoint = config.endpoint ?? "https://api.openai.com/v1/chat/completions";
+  }
+  async complete(systemPrompt, userPrompt) {
+    const body = {
+      model: this.model,
+      messages: [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: userPrompt }
+      ],
+      temperature: 0.2,
+      max_tokens: 16384
+    };
+    const response = await fetch(this.endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      throw new Error(`Provider returned ${response.status}: ${text.slice(0, 200)}`);
+    }
+    const data = await response.json();
+    const content = data?.choices?.[0]?.message?.content;
+    if (!content) {
+      throw new Error("Provider returned empty response \u2014 no content in choices[0].message.content");
+    }
+    return content;
+  }
+};
+function createProvider(config) {
+  return new ChatCompletionsProvider(config);
+}
+
+// src/engine/intent-classifier.ts
+function buildSystemPrompt(knownIntents) {
+  let prompt = `You are an intent classifier for an AI governance system. Your job is to analyze structured content fields and produce a clean, semantic intent label.
+
+CRITICAL RULES:
+1. Distinguish WHO is performing the action. If the AI agent says "I am escalating your request", that is the AI being polite \u2014 NOT the customer demanding escalation.
+2. Focus on the CUSTOMER'S actual intent, not the AI's response language.
+3. Return a short, snake_case intent label (e.g. "shipping_inquiry", "complaint_escalation", "password_reset").
+4. Assess the actor: who initiated this action? The customer, the AI agent, or the system?
+
+You must respond with ONLY valid JSON in this exact format:
+{"intent": "<label>", "confidence": <0-1>, "actor": "<customer|ai_agent|system|unknown>", "reasoning": "<one sentence>"}`;
+  if (knownIntents && knownIntents.length > 0) {
+    prompt += `
+
+Preferred intent labels (use these when applicable, but you may create new ones if none fit):
+${knownIntents.map((i) => `- ${i}`).join("\n")}`;
+  }
+  return prompt;
+}
+function buildUserPrompt(fields) {
+  const parts = [];
+  if (fields.customer_input) {
+    parts.push(`CUSTOMER INPUT:
+${fields.customer_input}`);
+  }
+  if (fields.draft_reply) {
+    parts.push(`AI DRAFT REPLY:
+${fields.draft_reply}`);
+  }
+  if (fields.tool) {
+    parts.push(`TOOL: ${fields.tool}`);
+  }
+  if (fields.context) {
+    parts.push(`CONTEXT: ${fields.context}`);
+  }
+  if (fields.raw && parts.length === 0) {
+    parts.push(`RAW TEXT:
+${fields.raw}`);
+  }
+  return parts.join("\n\n");
+}
+async function classifyIntentWithAI(fields, options) {
+  const provider = createProvider(options.ai);
+  const systemPrompt = buildSystemPrompt(options.knownIntents);
+  const userPrompt = buildUserPrompt(fields);
+  const response = await provider.complete(systemPrompt, userPrompt);
+  const jsonMatch = response.match(/\{[\s\S]*\}/);
+  if (!jsonMatch) {
+    throw new Error("Intent classifier returned non-JSON response");
+  }
+  const parsed = JSON.parse(jsonMatch[0]);
+  if (!parsed.intent || typeof parsed.intent !== "string") {
+    throw new Error("Intent classifier returned invalid intent label");
+  }
+  return {
+    intent: parsed.intent,
+    confidence: typeof parsed.confidence === "number" ? parsed.confidence : 0.5,
+    actor: ["customer", "ai_agent", "system", "unknown"].includes(
+      parsed.actor
+    ) ? parsed.actor : "unknown",
+    reasoning: parsed.reasoning ?? ""
+  };
+}
+var OUTPUT_CONTENT_FIELDS = /* @__PURE__ */ new Set([
+  "draft_reply",
+  "content",
+  "body",
+  "message",
+  "text",
+  "reply",
+  "response",
+  "output",
+  "html",
+  "template"
+]);
+function extractContentFields(intent, args) {
+  if (!args) {
+    return { raw: intent };
+  }
+  const fields = {};
+  let hasStructuredContent = false;
+  for (const [key, value] of Object.entries(args)) {
+    if (typeof value !== "string") continue;
+    const lowerKey = key.toLowerCase();
+    if (OUTPUT_CONTENT_FIELDS.has(lowerKey)) {
+      fields.draft_reply = fields.draft_reply ? `${fields.draft_reply}
+
+${value}` : value;
+      hasStructuredContent = true;
+    }
+  }
+  if (hasStructuredContent) {
+    fields.customer_input = intent;
+  } else {
+    fields.raw = intent;
+  }
+  return fields;
+}
+
+// src/engine/ai-guard.ts
+async function evaluateGuardWithAI(event, world, options = {}) {
+  if (!options.ai) {
+    const verdict = evaluateGuard(event, world, options);
+    verdict.intent_source = "raw";
+    return verdict;
+  }
+  const fallbackOnError = options.fallbackOnError ?? true;
+  const originalIntent = event.intent;
+  const knownIntents = options.knownIntents ?? extractKnownIntents(world);
+  const contentFields = options.contentFields ?? extractContentFields(event.intent, event.args);
+  try {
+    const classification = await classifyIntentWithAI(contentFields, {
+      ai: options.ai,
+      knownIntents
+    });
+    const classifiedEvent = {
+      ...event,
+      intent: classification.intent
+    };
+    const verdict = evaluateGuard(classifiedEvent, world, options);
+    verdict.intent_source = "ai";
+    verdict.classification = classification;
+    verdict.originalIntent = originalIntent;
+    return verdict;
+  } catch (err) {
+    if (fallbackOnError) {
+      const verdict = evaluateGuard(event, world, options);
+      verdict.intent_source = "fallback";
+      verdict.originalIntent = originalIntent;
+      return verdict;
+    }
+    throw err;
+  }
+}
+function extractKnownIntents(world) {
+  const vocab = world.guards?.intent_vocabulary;
+  if (!vocab) return [];
+  return Object.keys(vocab);
+}
+
 // src/contracts/guard-contract.ts
 var GUARD_EXIT_CODES = {
   ALLOW: 0,
@@ -5962,7 +6150,7 @@ H2 sub-sections defining computed outcomes:
 - label: Human Label
 - primary: true (for the main metric)
 `.trim();
-async function buildSystemPrompt() {
+async function buildSystemPrompt2() {
   const derivationWorld = await loadDerivationWorld();
   const invariantLines = derivationWorld.split("\n").filter((l) => l.trim().startsWith("- `")).map((l) => {
     const match = l.match(/^-\s+`([^`]+)`\s*[—–-]\s*(.+?)(?:\s*\([^)]+\))?\s*$/);
@@ -6012,7 +6200,7 @@ EFFECTS: Every effect MUST use a recognized operator:
   CORRECT: Then score *= 0.50, active = false
   WRONG:   Then score decreases by half`;
 }
-function buildUserPrompt(concatenatedMarkdown) {
+function buildUserPrompt2(concatenatedMarkdown) {
   return `Synthesize a valid .nv-world.md under DerivationWorld constraints from the following source material.
 
 Output ONLY the .nv-world.md content. Start with the --- frontmatter delimiter.
@@ -6022,50 +6210,6 @@ Source material:
 ${concatenatedMarkdown}`;
 }
 
-// src/providers/ai-provider.ts
-var ChatCompletionsProvider = class {
-  model;
-  apiKey;
-  endpoint;
-  constructor(config) {
-    this.model = config.model;
-    this.apiKey = config.apiKey;
-    this.endpoint = config.endpoint ?? "https://api.openai.com/v1/chat/completions";
-  }
-  async complete(systemPrompt, userPrompt) {
-    const body = {
-      model: this.model,
-      messages: [
-        { role: "system", content: systemPrompt },
-        { role: "user", content: userPrompt }
-      ],
-      temperature: 0.2,
-      max_tokens: 16384
-    };
-    const response = await fetch(this.endpoint, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${this.apiKey}`
-      },
-      body: JSON.stringify(body)
-    });
-    if (!response.ok) {
-      const text = await response.text().catch(() => "");
-      throw new Error(`Provider returned ${response.status}: ${text.slice(0, 200)}`);
-    }
-    const data = await response.json();
-    const content = data?.choices?.[0]?.message?.content;
-    if (!content) {
-      throw new Error("Provider returned empty response \u2014 no content in choices[0].message.content");
-    }
-    return content;
-  }
-};
-function createProvider(config) {
-  return new ChatCompletionsProvider(config);
-}
-
 // src/providers/config-manager.ts
 var import_promises2 = require("fs/promises");
 var import_path4 = require("path");
@@ -6168,8 +6312,8 @@ async function deriveWorld(options) {
     throw new DeriveInputError("No markdown files found in input path");
   }
   const concatenated = concatenateSources(sources);
-  const systemPrompt = await buildSystemPrompt();
-  const userPrompt = buildUserPrompt(concatenated);
+  const systemPrompt = await buildSystemPrompt2();
+  const userPrompt = buildUserPrompt2(concatenated);
   if (options.dryRun) {
     return {
       result: {
@@ -7537,6 +7681,7 @@ function handleCreateCapsule(body) {
   buildPlanCheck,
   classifyAdaptation,
   classifyIntent,
+  classifyIntentWithAI,
   createAgentState,
   createGovernanceEngine,
   createGovernor,
@@ -7546,9 +7691,11 @@ function handleCreateCapsule(body) {
   emitWorldDefinition,
   evaluateCondition,
   evaluateGuard,
+  evaluateGuardWithAI,
   evaluatePlan,
   eventToAllowlistKey,
   explainWorld,
+  extractContentFields,
   extractWorldMarkdown,
   formatVerdict,
   formatVerdictOneLine,