@neuroverseos/nv-sim 0.1.9 → 0.1.10

package/dist/engine/intentTranslator.js

@@ -0,0 +1,281 @@
+"use strict";
+/**
+ * Intent Translator — Natural Language → World Rules
+ *
+ * Scientists describe what they want in plain language.
+ * AI translates that into NeuroverseOS governance rules.
+ *
+ * Uses the same AI provider infrastructure (BYOM) as the rest of the system.
+ * Falls back to deterministic heuristics when no AI is configured.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translateIntent = translateIntent;
+const aiProvider_1 = require("./aiProvider");
+// ============================================
+// SYSTEM PROMPT
+// ============================================
+const TRANSLATE_INTENT_PROMPT = `You are a governance rule translator for NeuroverseOS, a system that governs how AI agent swarms behave during scientific discovery.
+
+A scientist has described their research intent in five categories:
+- EXPLORE: What agents should investigate (becomes ALLOW rules and domain scope)
+- EXCLUDE: What should never be concluded or published (becomes BLOCK rules)
+- ELEVATE: What makes results valuable (becomes PRIORITIZE rules)
+- EXPERIMENT: If/then rules with explicit verdicts (becomes REWARD, PENALIZE, or NEUTRAL rules)
+- OPEN-ENDED: Free-form ideas the scientist wants to test (translate into the most appropriate rule types)
+
+Translate their intent into structured governance rules. Return ONLY valid JSON:
+{
+  "worldName": "short name for this research world (max 50 chars)",
+  "thesis": "one-sentence thesis for this world",
+  "rules": [
+    {
+      "source": "explore|exclude|elevate|experiment|open_ended",
+      "naturalLanguage": "human-readable rule description",
+      "ruleType": "ALLOW|BLOCK|PRIORITIZE|GATE|REWARD|PENALIZE|NEUTRAL",
+      "condition": {
+        "field": "the state/result field to check (e.g. result.confidence, action.domain, result.sources_count, agent.behavior, agent.influence)",
+        "operator": ">|<|>=|<=|==|!=|contains|matches",
+        "value": "the threshold or match value"
+      },
+      "effect": "what happens — for REWARD: boost_influence, priority, faster_execution, weight_increase. For PENALIZE: freeze, reduce_influence, increase_risk, cooldown. Include magnitude and rounds where appropriate.",
+      "confidence": 0.0-1.0
+    }
+  ],
+  "suggestedInvariants": ["immutable rules that should never be violated"]
+}
+
+Guidelines:
+- Each natural language sentence should produce at least one rule
+- EXCLUDE items → BLOCK rules with specific, enforceable conditions
+- ELEVATE items → PRIORITIZE rules that boost result ranking
+- EXPLORE items → ALLOW rules that define the investigation scope
+- EXPERIMENT if/then items → REWARD or PENALIZE rules with concrete consequences (e.g. "freeze for 3 rounds", "boost influence by 2x")
+- OPEN-ENDED items → use your best judgment to create the most appropriate rule types. These are experimental — the scientist is exploring what's possible
+- Be specific about conditions — use quantitative thresholds where the user implies them
+- If the user says "confidence below 70%", the condition should be {field: "result.confidence", operator: "<", value: 0.7}
+- suggestedInvariants are the hardest constraints — things that must NEVER be violated`;
+// ============================================
+// MAIN TRANSLATION FUNCTION
+// ============================================
+/**
+ * Translate a scientist's natural language intent into governance rules.
+ * Uses AI when available, falls back to deterministic parsing.
+ */
+async function translateIntent(intent) {
+    const providerName = (0, aiProvider_1.getDefaultProviderName)();
+    if (providerName === "deterministic") {
+        return deterministicTranslation(intent);
+    }
+    try {
+        const provider = (0, aiProvider_1.getAIProvider)(providerName);
+        return await aiTranslation(intent, provider);
+    }
+    catch {
+        // AI failed — fall back to deterministic
+        return deterministicTranslation(intent);
+    }
+}
+// ============================================
+// AI-POWERED TRANSLATION
+// ============================================
+async function aiTranslation(intent, provider) {
+    const experimentText = intent.experiment.length > 0
+        ? intent.experiment.map(r => `- IF ${r.condition} THEN ${r.outcome} [${r.verdict}]`).join("\n")
+        : "(none)";
+    const userMessage = `Translate this research intent into governance rules:
+
+EXPLORE (what to investigate):
+${intent.explore || "(not specified)"}
+
+EXCLUDE (what to reject):
+${intent.exclude || "(not specified)"}
+
+ELEVATE (what to trust):
+${intent.elevate || "(not specified)"}
+
+EXPERIMENT (if/then rules):
+${experimentText}
+
+OPEN-ENDED (other things to try):
+${intent.openEnded || "(not specified)"}`;
+    let text;
+    if (provider instanceof aiProvider_1.AnthropicProvider) {
+        const client = await provider.getClient();
+        const response = await client.messages.create({
+            model: provider.model,
+            max_tokens: 1024,
+            system: TRANSLATE_INTENT_PROMPT,
+            messages: [{ role: "user", content: userMessage }],
+        });
+        text = response.content[0]?.type === "text" ? response.content[0].text : "{}";
+    }
+    else if (provider instanceof aiProvider_1.OpenAICompatibleProvider) {
+        text = await provider.chatCompletion(TRANSLATE_INTENT_PROMPT, userMessage, 1024);
+    }
+    else {
+        // Generic provider — use translate method as proxy
+        return deterministicTranslation(intent);
+    }
+    try {
+        const parsed = JSON.parse(text);
+        return {
+            rules: (parsed.rules ?? []).map((r, i) => ({
+                id: `ai_rule_${i}`,
+                source: r.source ?? "explore",
+                naturalLanguage: r.naturalLanguage ?? "",
+                ruleType: r.ruleType ?? "ALLOW",
+                condition: r.condition ?? { field: "unknown", operator: "==", value: true },
+                effect: r.effect ?? "",
+                confidence: r.confidence ?? 0.7,
+            })),
+            worldName: parsed.worldName ?? deriveWorldName(intent),
+            thesis: parsed.thesis ?? `Research world for: ${intent.explore.slice(0, 80)}`,
+            suggestedInvariants: parsed.suggestedInvariants ?? [],
+            translatedBy: `ai:${provider.name}`,
+        };
+    }
+    catch {
+        return deterministicTranslation(intent);
+    }
+}
+// ============================================
+// DETERMINISTIC FALLBACK
+// ============================================
+function deterministicTranslation(intent) {
+    const rules = [];
+    let idx = 0;
+    // EXPLORE → ALLOW rules
+    for (const sentence of splitSentences(intent.explore)) {
+        rules.push({
+            id: `rule_${idx++}`,
+            source: "explore",
+            naturalLanguage: `Agents should investigate: ${sentence}`,
+            ruleType: "ALLOW",
+            condition: { field: "action.domain", operator: "matches", value: extractKeyTerms(sentence) },
+            effect: "Allow investigation with priority",
+            confidence: 0.8,
+        });
+    }
+    // EXCLUDE → BLOCK rules
+    for (const sentence of splitSentences(intent.exclude)) {
+        const { field, operator, value } = parseBlockCondition(sentence);
+        rules.push({
+            id: `rule_${idx++}`,
+            source: "exclude",
+            naturalLanguage: `Block: ${sentence}`,
+            ruleType: "BLOCK",
+            condition: { field, operator, value },
+            effect: "Block action or publication",
+            confidence: 0.85,
+        });
+    }
+    // ELEVATE → PRIORITIZE rules
+    for (const sentence of splitSentences(intent.elevate)) {
+        rules.push({
+            id: `rule_${idx++}`,
+            source: "elevate",
+            naturalLanguage: `Prioritize: ${sentence}`,
+            ruleType: "PRIORITIZE",
+            condition: { field: "result.quality", operator: "matches", value: sentence.slice(0, 80) },
+            effect: "Boost priority score by 2x",
+            confidence: 0.75,
+        });
+    }
+    // EXPERIMENT if/then → REWARD / PENALIZE / NEUTRAL
+    for (const ifThen of intent.experiment) {
+        const effectMap = {
+            REWARD: `boost_influence for 3 rounds: ${ifThen.outcome}`,
+            PENALIZE: `reduce_influence for 3 rounds: ${ifThen.outcome}`,
+            NEUTRAL: `log observation: ${ifThen.outcome}`,
+        };
+        rules.push({
+            id: `rule_${idx++}`,
+            source: "experiment",
+            naturalLanguage: `If ${ifThen.condition} → ${ifThen.outcome}`,
+            ruleType: ifThen.verdict,
+            condition: { field: "agent.behavior", operator: "matches", value: ifThen.condition.slice(0, 80) },
+            effect: effectMap[ifThen.verdict] ?? ifThen.outcome,
+            confidence: 0.9,
+        });
+    }
+    // OPEN-ENDED → NEUTRAL rules (AI would do better)
+    for (const sentence of splitSentences(intent.openEnded)) {
+        rules.push({
+            id: `rule_${idx++}`,
+            source: "open_ended",
+            naturalLanguage: sentence,
+            ruleType: "NEUTRAL",
+            condition: { field: "scenario.context", operator: "matches", value: extractKeyTerms(sentence) },
+            effect: "Experimental rule — AI will refine into specific governance",
+            confidence: 0.6,
+        });
+    }
+    // Derive invariants from EXCLUDE items
+    const invariants = splitSentences(intent.exclude)
+        .filter(s => {
+        const lower = s.toLowerCase();
+        return lower.includes("never") || lower.includes("must not") || lower.includes("contradict");
+    })
+        .map(s => s);
+    return {
+        rules,
+        worldName: deriveWorldName(intent),
+        thesis: intent.explore.trim()
+            ? `Governed investigation of: ${intent.explore.split(/[.;\n]/)[0].trim().slice(0, 100)}`
+            : "Custom governed research world",
+        suggestedInvariants: invariants,
+        translatedBy: "deterministic",
+    };
+}
+// ============================================
+// HELPERS
+// ============================================
+function splitSentences(text) {
+    if (!text.trim())
+        return [];
+    return text
+        .split(/[.;\n]+/)
+        .map(s => s.trim())
+        .filter(s => s.length > 3);
+}
+function extractKeyTerms(text) {
+    const stopWords = new Set([
+        "the", "a", "an", "and", "or", "but", "in", "on", "at", "to", "for",
+        "of", "with", "by", "that", "this", "is", "are", "was", "were", "be",
+        "been", "being", "have", "has", "had", "do", "does", "did", "will",
+        "would", "could", "should", "may", "might", "can",
+    ]);
+    return text
+        .toLowerCase()
+        .split(/\s+/)
+        .filter(w => w.length > 2 && !stopWords.has(w))
+        .slice(0, 6)
+        .join(" ");
+}
+function parseBlockCondition(text) {
+    const lower = text.toLowerCase();
+    if (lower.includes("single") && lower.includes("source")) {
+        return { field: "result.sources_count", operator: "<", value: 2 };
+    }
+    if (lower.includes("confidence") || lower.includes("below")) {
+        const match = text.match(/(\d+)%?/);
+        const threshold = match ? parseInt(match[1]) / 100 : 0.7;
+        return { field: "result.confidence", operator: "<", value: threshold };
+    }
+    if (lower.includes("reproduc")) {
+        return { field: "result.reproducible", operator: "==", value: false };
+    }
+    if (lower.includes("contradict")) {
+        return { field: "result.contradicts_laws", operator: "==", value: true };
+    }
+    return { field: "result.excluded_pattern", operator: "matches", value: text.slice(0, 80) };
+}
+function deriveWorldName(intent) {
+    const explore = intent.explore.trim();
+    if (!explore)
+        return "Custom World";
+    const first = explore.split(/[.,;\n]/)[0].trim();
+    if (first.length <= 50)
+        return first;
+    return first.slice(0, 47) + "...";
+}

package/dist/engine/liveAdapter.js

@@ -24,11 +24,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ADAPTER_REGISTRY = void 0;
 exports.createProcessAdapter = createProcessAdapter;
-exports.parseMiroFishLine = parseMiroFishLine;
+exports.parseStepBasedLine = parseStepBasedLine;
 exports.parseGenericJsonLine = parseGenericJsonLine;
+exports.parseScienceClawLine = parseScienceClawLine;
 exports.createAdapter = createAdapter;
 const child_process_1 = require("child_process");
 const events_1 = require("events");
+const types_1 = require("../runtime/types");
 function createParserState() {
     return {
         currentRound: 0,
@@ -44,10 +46,10 @@ function createParserState() {
  * Usage:
  *   const adapter = createProcessAdapter({
  *     type: "process",
- *     label: "MiroFish (Live)",
+ *     label: "My Simulation (Live)",
  *     command: "node",
- *     args: ["mirofish.js"],
- *     parser: parseMiroFishLine,
+ *     args: ["sim.js"],
+ *     parser: parseStepBasedLine,
  *   });
  *   adapter.on("round", (round) => { ... });
  *   await adapter.start();
@@ -145,12 +147,12 @@ function createProcessAdapter(config) {
     return emitter;
 }
 // ============================================
-// MIROFISH STDOUT PARSER
+// GENERIC STEP-BASED STDOUT PARSER
 // ============================================
 /**
- * Parses MiroFish stdout line-by-line.
+ * Parses step-based stdout line-by-line.
  *
- * Expected MiroFish output formats:
+ * Expected output formats:
  *
  * JSON-per-line (preferred):
  *   {"step":1,"agent_actions":[{"agent_id":"a1","action":"buy","sentiment":0.5,"confidence":0.8}]}
@@ -164,7 +166,7 @@ function createProcessAdapter(config) {
  * We emit a LiveSimulationRound when we detect a new step number
  * (meaning the previous step is complete).
  */
-function parseMiroFishLine(line, state) {
+function parseStepBasedLine(line, state) {
     // Try JSON first
     if (line.startsWith("{")) {
         try {
@@ -199,7 +201,7 @@ function parseMiroFishLine(line, state) {
                 // Complete step as JSON — emit immediately
                 return {
                     round: data.step,
-                    source: "mirofish",
+                    source: "generic",
                     agentActions: data.agent_actions.map((a) => ({
                         agent: a.agent_id ?? a.agent ?? "unknown",
                         action: a.action ?? "",
@@ -227,7 +229,7 @@ function parseMiroFishLine(line, state) {
     if (stepNum > state.currentRound && state.currentRound > 0) {
         result = {
             round: state.currentRound,
-            source: "mirofish",
+            source: "generic",
             agentActions: [...state.pendingActions],
             systemEvents: state.pendingEvents.length > 0 ? [...state.pendingEvents] : undefined,
             emergentDynamics: state.pendingDynamics.length > 0 ? [...state.pendingDynamics] : undefined,
@@ -303,18 +305,98 @@ function parseGenericJsonLine(line, _state) {
         return null;
     }
 }
+// ============================================
+// SCIENCECLAW STDOUT PARSER
+// ============================================
+/**
+ * Parses structured JSON lines emitted by ScienceClaw.
+ *
+ * IMPORTANT: Schema-gated governance — only strict JSON lines are processed.
+ * Non-JSON output is passed through without evaluation (by design).
+ * No regex or heuristic parsing is used, for safety and determinism.
+ *
+ * Expected format (one JSON object per line):
+ *   {"cycle":1,"artifacts":[{"agent_id":"a1","type":"hypothesis","description":"...","confidence":0.7}]}
+ *
+ * Also accepted (alternate field names, same structure):
+ *   {"step":1,"agents":[...]}
+ *   {"round":1,"agent_actions":[...]}
+ *
+ * Any future formats must be added as explicit structured cases — never inferred.
+ */
+function parseScienceClawLine(line, _state) {
+    if (!line.startsWith("{"))
+        return null;
+    let data;
+    try {
+        data = JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+    // ── Route through NV Governance Schema v1 ──
+    const validated = (0, types_1.validateGovernableCycle)(data, "scienceclaw");
+    // Schema validation failed — line is ungovernable
+    if (typeof validated === "string")
+        return null;
+    // Map validated NVGovernableEvents → LiveAgentActions
+    const agents = validated.events.map((ev) => {
+        // Confidence-weighted impact: higher confidence + reproduced = more constructive
+        const impact = ev.reproduced
+            ? Math.min(1, ev.confidence * 0.8 + 0.2) // reproduced = positive signal
+            : (ev.confidence - 0.4) * 1.2; // unreproduced = depends on confidence
+        return {
+            agent: ev.agentId,
+            action: ev.actionType,
+            impact: Number(Math.max(-1, Math.min(1, impact)).toFixed(3)),
+            confidence: ev.confidence,
+            metadata: {
+                artifactType: ev.actionType,
+                reproduced: ev.reproduced,
+                citations: ev.references,
+                description: ev.description,
+                nvSchema: ev.schema,
+            },
+        };
+    });
+    // Map reactor matches to system events (pass-through, not schema-gated)
+    const matches = (data.matches ?? data.reactor_matches ?? []);
+    const systemEvents = matches.map((m) => ({
+        id: m.matchType ?? m.type ?? "match",
+        label: m.description ?? `${m.matchType ?? "match"} (strength: ${(m.strength ?? 0).toFixed(2)})`,
+        severity: (m.matchType === "contradiction" || m.type === "contradiction")
+            ? "moderate"
+            : "minor",
+    }));
+    // Extract emergent dynamics (pass-through)
+    const dynamics = (data.dynamics ?? data.emergent ?? []);
+    if (data.convergence_detected) {
+        dynamics.push("convergence_detected");
+    }
+    if (data.risk_flags) {
+        const flags = data.risk_flags;
+        dynamics.push(...(Array.isArray(flags) ? flags : [flags]));
+    }
+    return {
+        round: validated.cycle,
+        source: validated.source,
+        agentActions: agents,
+        systemEvents,
+        emergentDynamics: dynamics,
+    };
+}
 exports.ADAPTER_REGISTRY = {
-    mirofish: {
-        id: "mirofish",
-        label: "MiroFish (Live)",
-        description: "Spawn MiroFish swarm simulation and stream agent behavior",
+    scienceclaw: {
+        id: "scienceclaw",
+        label: "ScienceClaw (Live)",
+        description: "Spawn ScienceClaw investigation and govern artifact cycles in real time",
         createConfig: (opts = {}) => ({
             type: "process",
-            label: "MiroFish (Live)",
-            command: opts.command ?? "node",
-            args: (opts.args ?? "mirofish.js").split(" "),
+            label: "ScienceClaw (Live)",
+            command: opts.command ?? "scienceclaw-post",
+            args: (opts.args ?? "").split(" ").filter(Boolean),
             cwd: opts.cwd,
-            parser: parseMiroFishLine,
+            parser: parseScienceClawLine,
         }),
     },
     generic: {