@holoscript/core 8.0.8 → 8.0.10

package/dist/chunk-UNMVGZVW.js

@@ -0,0 +1,142 @@
+// src/traits/cognitive/CognitiveActions.ts
+var COGNITIVE_VERBS = [
+  "llm_call",
+  "recall",
+  "rag_query",
+  "plan",
+  "reflect"
+];
+function isCognitiveVerb(value) {
+  return COGNITIVE_VERBS.includes(value);
+}
+var BRAIN_KEYWORD = "brain";
+function isBrainKeyword(value) {
+  return value === BRAIN_KEYWORD;
+}
+var AI_TRAIT_NAMES = [
+  "llm_agent",
+  "ai_npc_brain",
+  "agent_memory",
+  "rag_knowledge",
+  "goal_oriented",
+  "perception",
+  "behavior_tree"
+];
+function editDistance(a, b) {
+  const m = a.length;
+  const n = b.length;
+  const dp = Array.from({ length: n + 1 }, (_, j) => j);
+  for (let i = 1; i <= m; i++) {
+    let prev = dp[0];
+    dp[0] = i;
+    for (let j = 1; j <= n; j++) {
+      const tmp = dp[j];
+      dp[j] = a[i - 1] === b[j - 1] ? prev : 1 + Math.min(prev, dp[j], dp[j - 1]);
+      prev = tmp;
+    }
+  }
+  return dp[n];
+}
+function nearestCognitiveVerb(value) {
+  if (isCognitiveVerb(value)) return void 0;
+  let best;
+  let bestDist = Infinity;
+  for (const verb of COGNITIVE_VERBS) {
+    const d = editDistance(value, verb);
+    if (d < bestDist) {
+      bestDist = d;
+      best = verb;
+    }
+  }
+  return best && value.length >= 3 && bestDist <= 2 ? best : void 0;
+}
+var COGNITIVE_EVENT_MAP = {
+  // LLMAgentTrait.onEvent consumes `llm_prompt` (reads event.message); emits `llm_message`.
+  llm_call: { request: "llm_prompt", complete: "llm_message", trait: "llm_agent" },
+  // AgentMemoryTrait.onEvent consumes `memory_recall` (reads event.payload); emits `memory_recalled`.
+  recall: { request: "memory_recall", complete: "memory_recalled", trait: "agent_memory" },
+  // RAGKnowledgeTrait.onEvent consumes `rag_query` (reads event.question); emits `on_knowledge_retrieved`.
+  rag_query: { request: "rag_query", complete: "on_knowledge_retrieved", trait: "rag_knowledge" },
+  // GoalOrientedTrait.onEvent consumes `goap_set_state` (reads event.state → selectGoalAndPlan); emits `goap_plan_created`.
+  plan: { request: "goap_set_state", complete: "goap_plan_created", trait: "goal_oriented" },
+  // reflect composes a self-evaluation LLM turn — dispatches to LLMAgentTrait; no separate trait.
+  reflect: { request: "llm_prompt", complete: "llm_message", trait: "llm_agent" }
+};
+var COGNITIVE_COMPLETE_TO_VERB = (() => {
+  const out = {};
+  for (const verb of COGNITIVE_VERBS) {
+    const ev = COGNITIVE_EVENT_MAP[verb].complete;
+    (out[ev] || (out[ev] = [])).push(verb);
+  }
+  return out;
+})();
+function str(config, ...keys) {
+  for (const k of keys) {
+    const v = config[k];
+    if (typeof v === "string") return v;
+  }
+  return "";
+}
+function compileCognitiveDispatch(action, requestId, owner) {
+  const c = action.config || {};
+  const binding = COGNITIVE_EVENT_MAP[action.verb];
+  const base = { node: owner, owner, requestId };
+  switch (action.verb) {
+    case "llm_call":
+      return { event: binding.request, payload: { ...base, message: str(c, "prompt", "message") } };
+    case "reflect": {
+      const subject = str(c, "subject", "of") || "the previous action result";
+      const criteria = str(c, "criteria", "scorer") || "correctness and completeness";
+      return {
+        event: binding.request,
+        payload: { ...base, message: `Reflect on ${subject}. Evaluate it for: ${criteria}.` }
+      };
+    }
+    case "recall":
+      return {
+        event: binding.request,
+        payload: {
+          ...base,
+          payload: {
+            query: str(c, "query"),
+            top_k: typeof c.top_k === "number" ? c.top_k : typeof c.limit === "number" ? c.limit : void 0,
+            tags: Array.isArray(c.tags) ? c.tags : void 0,
+            embedding: Array.isArray(c.embedding) ? c.embedding : void 0
+          }
+        }
+      };
+    case "rag_query":
+      return { event: binding.request, payload: { ...base, question: str(c, "query", "question") } };
+    case "plan": {
+      const state = c.state ?? c.worldState ?? c.beliefs ?? {};
+      return { event: binding.request, payload: { ...base, state } };
+    }
+    default: {
+      const _never = action.verb;
+      return { event: String(_never), payload: base };
+    }
+  }
+}
+function cognitiveActionsToBTNodes(actions) {
+  if (!actions || actions.length === 0) return [];
+  const out = [];
+  for (const a of actions) {
+    if (!a || a.kind !== "cognitive" || !isCognitiveVerb(a.verb)) continue;
+    const config = a.config ?? {};
+    const node = { type: "cognitive", verb: a.verb, config };
+    if (config.await === true) node.await = true;
+    const rk = config.result_key ?? config.result ?? config.into;
+    if (typeof rk === "string") node.result_key = rk;
+    out.push(node);
+  }
+  return out;
+}
+function cognitiveActionsToBehaviorTree(actions) {
+  const children = cognitiveActionsToBTNodes(actions);
+  if (children.length === 0) return void 0;
+  return { root: { type: "sequence", name: "brain_cognition", children } };
+}
+
+export { AI_TRAIT_NAMES, BRAIN_KEYWORD, COGNITIVE_COMPLETE_TO_VERB, COGNITIVE_EVENT_MAP, COGNITIVE_VERBS, cognitiveActionsToBTNodes, cognitiveActionsToBehaviorTree, compileCognitiveDispatch, isBrainKeyword, isCognitiveVerb, nearestCognitiveVerb };
+//# sourceMappingURL=chunk-UNMVGZVW.js.map
+//# sourceMappingURL=chunk-UNMVGZVW.js.map

package/dist/{chunk-TEVX443G.js → chunk-UTUD6GJI.js}

@@ -1,4 +1,4 @@
-import { init_CompilerBase, CompilerBase } from './chunk-C7ZBSV2Q.js';
+import { init_CompilerBase, CompilerBase } from './chunk-DUG3OQAS.js';
 import { ANSCapabilityPath } from '@holoscript/core-types/ans';
 
 // src/compiler/ContextCompiler.ts
@@ -95,11 +95,14 @@ var ContextCompiler = class extends CompilerBase {
           files["SKILL.md"] = this.emitSkillMd(ast);
           break;
         case "anthropic_system_prompt":
+          files["anthropic.system.txt"] = this.emitAnthropicSystemPrompt(ast);
+          break;
         case "brain_includes":
+          files["context.includes.hsplus"] = this.emitBrainIncludes(ast);
+          break;
         case "mcp_context_loader":
-          throw new Error(
-            `Format "${format}" is a Phase 1+ follow-up; not yet emitted. See ai-ecosystem research/2026-05-06_context-as-compile-target.md section Recommended sequence for the rollout order.`
-          );
+          files["mcp-context-loader.json"] = this.emitMcpContextLoader(ast);
+          break;
         default: {
           const exhaustive = format;
           throw new Error(`Unknown emit format: ${String(exhaustive)}`);
@@ -1795,6 +1798,172 @@ var ContextCompiler = class extends CompilerBase {
     lines.push("");
     return lines.join("\n");
   }
+  // --- Phase 3: emit -- compile_to_anthropic_system_prompt ----------
+  /**
+   * Emit compact raw text for Anthropic SDK `messages.create({ system })`.
+   * This surface is runtime-only: refusals + hard-donts, not skill
+   * discovery, markdown output protocols, or registration metadata.
+   */
+  emitAnthropicSystemPrompt(ast) {
+    const lines = [];
+    if (ast.refusals.length === 0 && ast.hardDonts.length === 0) {
+      lines.push("HoloScript runtime context: no active refusals or hard-donts declared.");
+      return lines.join("\n");
+    }
+    lines.push("HoloScript runtime context. Follow these rules before answering or acting.");
+    if (ast.refusals.length > 0) {
+      lines.push("");
+      lines.push("Refusals:");
+      for (const refusal of ast.refusals) {
+        const doNot = refusal.doNot.length > 0 ? ` Do not: ${refusal.doNot.join(", ")}.` : "";
+        const reason = refusal.reason ? ` Reason: ${refusal.reason}.` : "";
+        lines.push(`- ${refusal.name}: when ${refusal.when}; do ${refusal.do}.${doNot}${reason}`);
+      }
+    }
+    if (ast.hardDonts.length > 0) {
+      lines.push("");
+      lines.push("Hard don'ts:");
+      for (const dont of ast.hardDonts) {
+        const alternative = dont.alternative ? ` Alternative: ${dont.alternative}.` : "";
+        const appliesTo = dont.appliesTo.length > 0 ? ` Applies to: ${dont.appliesTo.join(", ")}.` : "";
+        lines.push(`- ${dont.name}: ${dont.reason}.${alternative}${appliesTo}`);
+      }
+    }
+    return lines.join("\n");
+  }
+  // --- Phase 3: emit -- compile_to_brain_includes -------------------
+  /**
+   * Emit a `.hsplus` context fragment suitable for brain `@include`
+   * directives. The fragment is deliberately data-shaped so brain
+   * compositions can consume the same authority/rule payload without
+   * importing Markdown surface conventions.
+   */
+  emitBrainIncludes(ast) {
+    const lines = [];
+    lines.push("// Generated by HoloScript ContextCompiler (compile_to_brain_includes).");
+    lines.push("// Include this fragment from brain compositions that need shared context.");
+    lines.push("@context_include {");
+    if (ast.identity) {
+      lines.push(`  name: ${hsLiteral(ast.identity.name)}`);
+      lines.push(`  role: ${hsLiteral(ast.identity.role)}`);
+      lines.push(`  domain: ${hsLiteral(ast.identity.domain)}`);
+      lines.push(`  surface: ${hsLiteral(ast.identity.surface)}`);
+      lines.push(`  no_monopoly: ${ast.identity.noMonopoly ? "true" : "false"}`);
+    }
+    lines.push(`  authority_order: ${hsLiteral(ast.authorityOrder?.tiers ?? [])}`);
+    lines.push(
+      `  refusals: ${hsLiteral(
+        ast.refusals.map((refusal) => ({
+          name: refusal.name,
+          when: refusal.when,
+          do: refusal.do,
+          do_not: refusal.doNot,
+          reason: refusal.reason ?? null
+        }))
+      )}`
+    );
+    lines.push(
+      `  hard_donts: ${hsLiteral(
+        ast.hardDonts.map((dont) => ({
+          name: dont.name,
+          reason: dont.reason,
+          alternative: dont.alternative ?? null,
+          applies_to: dont.appliesTo
+        }))
+      )}`
+    );
+    lines.push(
+      `  skills: ${hsLiteral(
+        ast.skills.map((skill) => ({
+          name: skill.name,
+          invocable_as: skill.invocableAs,
+          authority: skill.authority,
+          authoritative_for: skill.authoritativeFor,
+          refusals: skill.refusals ?? []
+        }))
+      )}`
+    );
+    lines.push("}");
+    lines.push("");
+    return lines.join("\n");
+  }
+  // --- Phase 3: emit -- compile_to_mcp_context_loader ---------------
+  /**
+   * Emit a JSON manifest for session-start MCP/context loaders.
+   * Consumers get authority order, active runtime rules, and the skill
+   * registry without parsing Markdown.
+   */
+  emitMcpContextLoader(ast) {
+    const manifest = {
+      schema_version: "holoscript.context-loader.v1",
+      generated_by: "ContextCompiler",
+      identity: ast.identity ? {
+        name: ast.identity.name,
+        role: ast.identity.role,
+        domain: ast.identity.domain,
+        surface: ast.identity.surface,
+        no_monopoly: ast.identity.noMonopoly
+      } : null,
+      authority_order: ast.authorityOrder?.tiers ?? [],
+      active_rules: {
+        refusals: ast.refusals.map((refusal) => ({
+          name: refusal.name,
+          when: refusal.when,
+          do: refusal.do,
+          do_not: refusal.doNot,
+          reason: refusal.reason ?? null
+        })),
+        hard_donts: ast.hardDonts.map((dont) => ({
+          name: dont.name,
+          reason: dont.reason,
+          alternative: dont.alternative ?? null,
+          applies_to: dont.appliesTo
+        })),
+        defaults: ast.defaults.map((def) => ({
+          name: def.name,
+          when: def.when,
+          do: def.do,
+          reason: def.reason ?? null
+        })),
+        gap_rules: ast.gapRules.map((rule) => ({
+          name: rule.name,
+          when: rule.when,
+          do: rule.do,
+          do_not: rule.doNot,
+          reason: rule.reason ?? null
+        })),
+        citation_rules: ast.citationRules.map((rule) => ({
+          fluent_prose_threshold_chars: rule.fluentProseThresholdChars,
+          required: rule.required,
+          exemption: rule.exemption ?? null,
+          reason: rule.reason ?? null
+        })),
+        production_rule: ast.productionRule ? {
+          no_dev_no_mock_no_localhost: ast.productionRule.noDevNoMockNoLocalhost,
+          exception: ast.productionRule.exception ?? null
+        } : null,
+        hard_physical_gaps: ast.hardPhysicalGaps.map((gap) => ({
+          name: gap.name,
+          reason: gap.reason,
+          applies_to: gap.appliesTo,
+          alternative: gap.alternative ?? null
+        }))
+      },
+      skill_registry: ast.skills.map((skill) => ({
+        name: skill.name,
+        invocable_as: skill.invocableAs,
+        authority: skill.authority,
+        authoritative_for: skill.authoritativeFor,
+        refusals: skill.refusals ?? []
+      })),
+      includes: ast.includes.map((include) => ({
+        source: include.source,
+        selector: include.selector ?? null
+      }))
+    };
+    return `${JSON.stringify(manifest, null, 2)}
+`;
+  }
   appendTrackBAuthority(lines, ast) {
     if (ast.trackBAuthorities.length === 0) {
       return;
@@ -1911,6 +2080,9 @@ function boolField(cfg, key, fallback) {
 function mdTableCell(value) {
   return value.replace(/\|/g, "\\|").replace(/[\r\n]+/g, "<br>");
 }
+function hsLiteral(value) {
+  return JSON.stringify(value);
+}
 function yamlScalar(s) {
   if (/^[A-Za-z][A-Za-z0-9_-]*$/.test(s) && !YAML_RESERVED.has(s.toLowerCase())) {
     return s;
@@ -1978,5 +2150,5 @@ function toCursorSlug(name) {
 }
 
 export { ContextCompileError, ContextCompiler, createContextCompiler };
-//# sourceMappingURL=chunk-TEVX443G.js.map
-//# sourceMappingURL=chunk-TEVX443G.js.map
+//# sourceMappingURL=chunk-UTUD6GJI.js.map
+//# sourceMappingURL=chunk-UTUD6GJI.js.map

package/dist/chunk-UXBYA7DV.cjs

@@ -0,0 +1,155 @@
+'use strict';
+
+// src/traits/SensorSamplingTrait.ts
+function boxMuller(u1, u2) {
+  return Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+}
+function applyNoise(raw, noise) {
+  switch (noise.type) {
+    case "none":
+      return raw;
+    case "gaussian": {
+      const n = boxMuller(1 - Math.random(), Math.random());
+      return raw + noise.sigma * n;
+    }
+    case "uniform":
+      return raw + (Math.random() * 2 - 1) * noise.range;
+    case "quantized": {
+      const q = Math.round(raw / noise.step) * noise.step;
+      if (!noise.residualSigma) return q;
+      const n = boxMuller(1 - Math.random(), Math.random());
+      return q + noise.residualSigma * n;
+    }
+  }
+}
+var SensorRingBuffer = class {
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.head = 0;
+    this._size = 0;
+    this.buf = new Array(capacity);
+  }
+  push(r) {
+    this.buf[this.head] = r;
+    this.head = (this.head + 1) % this.capacity;
+    if (this._size < this.capacity) this._size++;
+  }
+  get size() {
+    return this._size;
+  }
+  /** Returns readings oldest-first. */
+  toArray() {
+    if (this._size === 0) return [];
+    const out = [];
+    const start = this._size < this.capacity ? 0 : this.head;
+    for (let i = 0; i < this._size; i++) {
+      out.push(this.buf[(start + i) % this.capacity]);
+    }
+    return out;
+  }
+  latest() {
+    if (this._size === 0) return void 0;
+    const idx = (this.head - 1 + this.capacity) % this.capacity;
+    return this.buf[idx];
+  }
+  clear() {
+    this.head = 0;
+    this._size = 0;
+  }
+};
+function recordReading(rawValue, noise, sensorId, timestamp) {
+  return {
+    sensorId,
+    rawValue,
+    noisyValue: applyNoise(rawValue, noise),
+    timestamp
+  };
+}
+function computeWindowStats(sensorId, buffer) {
+  const readings = buffer.toArray();
+  const count = readings.length;
+  if (count === 0) {
+    return { sensorId, readings, count: 0, mean: NaN, variance: NaN, min: Infinity, max: -Infinity };
+  }
+  let sum = 0;
+  let min = Infinity;
+  let max = -Infinity;
+  for (const r of readings) {
+    sum += r.noisyValue;
+    if (r.noisyValue < min) min = r.noisyValue;
+    if (r.noisyValue > max) max = r.noisyValue;
+  }
+  const mean = sum / count;
+  if (count < 2) {
+    return { sensorId, readings, count, mean, variance: NaN, min, max };
+  }
+  let ss = 0;
+  for (const r of readings) ss += (r.noisyValue - mean) ** 2;
+  const variance = ss / (count - 1);
+  return { sensorId, readings, count, mean, variance, min, max };
+}
+var NO_NOISE = { type: "none" };
+function getOrCreateState(node, config) {
+  if (!(node.__sensor_state instanceof Map)) {
+    const m = /* @__PURE__ */ new Map();
+    for (const ch of config.sensors) {
+      m.set(ch.id, {
+        buffer: new SensorRingBuffer(ch.bufferSize ?? 32),
+        config: ch
+      });
+    }
+    node.__sensor_state = m;
+  }
+  return node.__sensor_state;
+}
+var sensorSamplingHandler = {
+  name: "sensor_sampling",
+  defaultConfig: { sensors: [] },
+  onAttach(node, config) {
+    const n = node;
+    getOrCreateState(n, config);
+    n.__sensor_last = {};
+    n.__sensor_window = {};
+  },
+  onEvent(node, config, _ctx, event) {
+    const n = node;
+    const state = getOrCreateState(n, config);
+    if (event.type === "sensor.record") {
+      const req = event;
+      const id = req.sensorId ?? config.sensors[0]?.id;
+      if (!id) return;
+      const entry = state.get(id);
+      if (!entry) return;
+      const noise = req.noise ?? entry.config.noise ?? NO_NOISE;
+      const reading = recordReading(req.rawValue, noise, id, req.timestamp ?? 0);
+      entry.buffer.push(reading);
+      n.__sensor_last[id] = reading;
+      return;
+    }
+    if (event.type === "sensor.read_window") {
+      const req = event;
+      const id = req.sensorId ?? config.sensors[0]?.id;
+      if (!id) return;
+      const entry = state.get(id);
+      if (!entry) return;
+      const result = computeWindowStats(id, entry.buffer);
+      n.__sensor_window[id] = result;
+      return;
+    }
+    if (event.type === "sensor.reset") {
+      for (const entry of state.values()) entry.buffer.clear();
+      n.__sensor_last = {};
+      n.__sensor_window = {};
+      return;
+    }
+  }
+};
+
+exports.SensorRingBuffer = SensorRingBuffer;
+exports.applyNoise = applyNoise;
+exports.boxMuller = boxMuller;
+exports.computeWindowStats = computeWindowStats;
+exports.recordReading = recordReading;
+exports.sensorSamplingHandler = sensorSamplingHandler;
+//# sourceMappingURL=chunk-UXBYA7DV.cjs.map
+//# sourceMappingURL=chunk-UXBYA7DV.cjs.map