@forbocai/core 0.5.6 → 0.5.8

package/dist/index.js

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
@@ -20,243 +18,95 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/ans104.ts
-var ans104_exports = {};
-__export(ans104_exports, {
-  createArweaveDataItem: () => createArweaveDataItem
+// src/soul.ts
+var soul_exports = {};
+__export(soul_exports, {
+  createSoul: () => createSoul,
+  createSoulInstance: () => createSoulInstance,
+  deserializeSoul: () => deserializeSoul,
+  exportSoul: () => exportSoul,
+  getSoulList: () => getSoulList,
+  importSoulFromArweave: () => importSoulFromArweave,
+  serializeSoul: () => serializeSoul,
+  validateSoul: () => validateSoul
 });
-var import_base64url, import_buffer, import_crypto, import_pem, SIGNATURE_TYPE_ARWEAVE, SIGNATURE_LENGTH, OWNER_LENGTH, MAX_TAG_BYTES, stringToBuffer, concatBuffers, longToNByteArray, longTo8ByteArray, shortTo2ByteArray, AVSCTap, serializeTags, hash, deepHash, deepHashChunks, getSignatureData, signData, getOwner, getPem, createArweaveDataItem;
-var init_ans104 = __esm({
-  "src/ans104.ts"() {
+var createSoul, serializeSoul, deserializeSoul, exportSoul, importSoulFromArweave, getSoulList, createSoulInstance, validateSoul;
+var init_soul = __esm({
+  "src/soul.ts"() {
     "use strict";
-    import_base64url = __toESM(require("base64url"));
-    import_buffer = require("buffer");
-    import_crypto = require("crypto");
-    import_pem = require("arweave/node/lib/crypto/pem");
-    SIGNATURE_TYPE_ARWEAVE = 1;
-    SIGNATURE_LENGTH = 512;
-    OWNER_LENGTH = 512;
-    MAX_TAG_BYTES = 4096;
-    stringToBuffer = (value) => import_buffer.Buffer.from(value);
-    concatBuffers = (buffers) => import_buffer.Buffer.concat(buffers);
-    longToNByteArray = (bytes, long) => {
-      const byteArray = new Uint8Array(bytes);
-      if (long < 0) throw new Error("Array is unsigned, cannot represent -ve numbers");
-      if (long > 2 ** (bytes * 8) - 1) throw new Error(`Number ${long} is too large for an array of ${bytes} bytes`);
-      for (let index = 0; index < byteArray.length; index++) {
-        const byte = long & 255;
-        byteArray[index] = byte;
-        long = (long - byte) / 256;
-      }
-      return byteArray;
-    };
-    longTo8ByteArray = (long) => longToNByteArray(8, long);
-    shortTo2ByteArray = (short) => longToNByteArray(2, short);
-    AVSCTap = class {
-      constructor(buf = import_buffer.Buffer.alloc(MAX_TAG_BYTES), pos = 0) {
-        this.buf = buf;
-        this.pos = pos;
-      }
-      writeTags(tags) {
-        if (!Array.isArray(tags)) {
-          throw new Error("input must be array");
-        }
-        const n = tags.length;
-        if (n) {
-          this.writeLong(n);
-          for (let i = 0; i < n; i++) {
-            const tag = tags[i];
-            if (typeof tag?.name !== "string" || typeof tag?.value !== "string") {
-              throw new Error(`Invalid tag format for ${tag}, expected {name:string, value: string}`);
-            }
-            this.writeString(tag.name);
-            this.writeString(tag.value);
-          }
-        }
-        this.writeLong(0);
-      }
-      toBuffer() {
-        const buffer = import_buffer.Buffer.alloc(this.pos);
-        if (this.pos > this.buf.length) throw new Error(`Too many tag bytes (${this.pos} > ${this.buf.length})`);
-        this.buf.copy(buffer, 0, 0, this.pos);
-        return buffer;
-      }
-      writeLong(n) {
-        const buf = this.buf;
-        let f, m;
-        if (n >= -1073741824 && n < 1073741824) {
-          m = n >= 0 ? n << 1 : ~n << 1 | 1;
-          do {
-            buf[this.pos] = m & 127;
-            m >>= 7;
-          } while (m && (buf[this.pos++] |= 128));
-        } else {
-          f = n >= 0 ? n * 2 : -n * 2 - 1;
-          do {
-            buf[this.pos] = f & 127;
-            f /= 128;
-          } while (f >= 1 && (buf[this.pos++] |= 128));
-        }
-        this.pos++;
-        this.buf = buf;
-      }
-      writeString(s) {
-        const len = import_buffer.Buffer.byteLength(s);
-        const buf = this.buf;
-        this.writeLong(len);
-        let pos = this.pos;
-        this.pos += len;
-        if (this.pos > buf.length) {
-          return;
-        }
-        if (len > 64) {
-          this.buf.write(s, this.pos - len, len, "utf8");
-        } else {
-          let i, l, c1, c2;
-          for (i = 0, l = len; i < l; i++) {
-            c1 = s.charCodeAt(i);
-            if (c1 < 128) {
-              buf[pos++] = c1;
-            } else if (c1 < 2048) {
-              buf[pos++] = c1 >> 6 | 192;
-              buf[pos++] = c1 & 63 | 128;
-            } else if ((c1 & 64512) === 55296 && ((c2 = s.charCodeAt(i + 1)) & 64512) === 56320) {
-              c1 = 65536 + ((c1 & 1023) << 10) + (c2 & 1023);
-              i++;
-              buf[pos++] = c1 >> 18 | 240;
-              buf[pos++] = c1 >> 12 & 63 | 128;
-              buf[pos++] = c1 >> 6 & 63 | 128;
-              buf[pos++] = c1 & 63 | 128;
-            } else {
-              buf[pos++] = c1 >> 12 | 224;
-              buf[pos++] = c1 >> 6 & 63 | 128;
-              buf[pos++] = c1 & 63 | 128;
-            }
-          }
-        }
-        this.buf = buf;
-      }
-    };
-    serializeTags = (tags) => {
-      if (tags?.length === 0) {
-        return import_buffer.Buffer.allocUnsafe(0);
-      }
-      const tap = new AVSCTap();
-      tap.writeTags(tags);
-      return tap.toBuffer();
-    };
-    hash = (data, algorithm) => {
-      const algo = algorithm === "SHA-256" ? "sha256" : "sha384";
-      return (0, import_crypto.createHash)(algo).update(data).digest();
-    };
-    deepHash = async (data) => {
-      if (Array.isArray(data)) {
-        const tag2 = concatBuffers([stringToBuffer("list"), stringToBuffer(data.length.toString())]);
-        return deepHashChunks(data, hash(tag2, "SHA-384"));
-      }
-      const _data = data;
-      const tag = concatBuffers([stringToBuffer("blob"), stringToBuffer(_data.byteLength.toString())]);
-      const taggedHash = concatBuffers([hash(tag, "SHA-384"), hash(_data, "SHA-384")]);
-      return hash(taggedHash, "SHA-384");
-    };
-    deepHashChunks = async (chunks, acc) => {
-      if (chunks.length < 1) {
-        return acc;
+    createSoul = (id, name, persona, state, memories = []) => ({
+      id,
+      version: "1.0.0",
+      name,
+      persona,
+      state: { ...state },
+      memories: [...memories]
+    });
+    serializeSoul = (soul) => JSON.stringify(soul, null, 2);
+    deserializeSoul = (json) => {
+      const parsed = JSON.parse(json);
+      if (!parsed.id || !parsed.persona || !parsed.state) {
+        throw new Error("Invalid Soul format: missing required fields");
       }
-      const hashPair = concatBuffers([acc, await deepHash(chunks[0])]);
-      const newAcc = hash(hashPair, "SHA-384");
-      return deepHashChunks(chunks.slice(1), newAcc);
-    };
-    getSignatureData = async (signatureType, rawOwner, rawTarget, rawAnchor, rawTags, rawData) => {
-      return deepHash([
-        stringToBuffer("dataitem"),
-        stringToBuffer("1"),
-        stringToBuffer(signatureType.toString()),
-        rawOwner,
-        rawTarget,
-        rawAnchor,
-        rawTags,
-        rawData
-      ]);
+      return {
+        id: parsed.id,
+        version: parsed.version || "1.0.0",
+        name: parsed.name || "Unknown",
+        persona: parsed.persona,
+        state: parsed.state,
+        memories: parsed.memories || [],
+        signature: parsed.signature
+      };
     };
-    signData = async (pemKey, message) => {
-      return (0, import_crypto.createSign)("sha256").update(message).sign({
-        key: pemKey,
-        padding: import_crypto.constants.RSA_PKCS1_PSS_PADDING
+    exportSoul = async (agentId, _soul, config = {}) => {
+      const apiUrl = config.apiUrl || "https://api.forboc.ai";
+      const response = await fetch(`${apiUrl}/agents/${agentId}/soul/export`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({})
+        // Future: allow specifying memories to include
       });
+      if (!response.ok) {
+        throw new Error(`Soul export failed: ${response.statusText}`);
+      }
+      const data = await response.json();
+      return {
+        txId: data.txId,
+        url: data.url,
+        soul: _soul
+        // Return the local soul data as context
+      };
     };
-    getOwner = (jwk) => {
-      return import_base64url.default.toBuffer(jwk.n);
+    importSoulFromArweave = async (txId, config = {}) => {
+      const apiUrl = config.apiUrl || "https://api.forboc.ai";
+      const response = await fetch(`${apiUrl}/souls/${txId}`);
+      if (!response.ok) throw new Error(`Import failed: ${response.statusText}`);
+      const data = await response.json();
+      return data;
     };
-    getPem = (jwk) => {
-      const pem = (0, import_pem.jwkTopem)(jwk);
-      return typeof pem === "string" ? pem : pem.toString();
+    getSoulList = async (limit = 50, apiUrl = "https://api.forboc.ai") => {
+      const response = await fetch(`${apiUrl}/souls?limit=${limit}`);
+      if (!response.ok) return [];
+      const data = await response.json();
+      return data.souls || [];
     };
-    createArweaveDataItem = async (data, jwk, opts) => {
-      const rawOwner = getOwner(jwk);
-      if (rawOwner.byteLength !== OWNER_LENGTH) {
-        throw new Error(`Owner must be ${OWNER_LENGTH} bytes, but was ${rawOwner.byteLength}`);
-      }
-      const rawTarget = opts?.target ? import_base64url.default.toBuffer(opts.target) : import_buffer.Buffer.alloc(0);
-      const rawAnchor = opts?.anchor ? import_buffer.Buffer.from(opts.anchor) : import_buffer.Buffer.alloc(0);
-      const rawTags = (opts?.tags?.length ?? 0) > 0 ? serializeTags(opts?.tags) : import_buffer.Buffer.alloc(0);
-      const rawData = typeof data === "string" ? import_buffer.Buffer.from(data) : import_buffer.Buffer.from(data);
-      const targetLength = 1 + (rawTarget?.byteLength ?? 0);
-      const anchorLength = 1 + (rawAnchor?.byteLength ?? 0);
-      const tagsLength = 16 + (rawTags ? rawTags.byteLength : 0);
-      const dataLength = rawData.byteLength;
-      const length = 2 + SIGNATURE_LENGTH + OWNER_LENGTH + targetLength + anchorLength + tagsLength + dataLength;
-      const bytes = import_buffer.Buffer.alloc(length);
-      bytes.set(shortTo2ByteArray(SIGNATURE_TYPE_ARWEAVE), 0);
-      bytes.set(new Uint8Array(SIGNATURE_LENGTH).fill(0), 2);
-      bytes.set(rawOwner, 2 + SIGNATURE_LENGTH);
-      const position = 2 + SIGNATURE_LENGTH + OWNER_LENGTH;
-      bytes[position] = rawTarget.length > 0 ? 1 : 0;
-      if (rawTarget.length > 0) {
-        if (rawTarget.byteLength !== 32) throw new Error("Target must be 32 bytes");
-        bytes.set(rawTarget, position + 1);
-      }
-      const anchorStart = position + targetLength;
-      let tagsStart = anchorStart + 1;
-      bytes[anchorStart] = rawAnchor.length > 0 ? 1 : 0;
-      if (rawAnchor.length > 0) {
-        tagsStart += rawAnchor.byteLength;
-        if (rawAnchor.byteLength !== 32) throw new Error("Anchor must be 32 bytes");
-        bytes.set(rawAnchor, anchorStart + 1);
-      }
-      bytes.set(longTo8ByteArray(opts?.tags?.length ?? 0), tagsStart);
-      bytes.set(longTo8ByteArray(rawTags?.byteLength ?? 0), tagsStart + 8);
-      if (rawTags.length > 0) {
-        bytes.set(rawTags, tagsStart + 16);
-      }
-      const dataStart = tagsStart + tagsLength;
-      bytes.set(rawData, dataStart);
-      const signatureData = await getSignatureData(
-        SIGNATURE_TYPE_ARWEAVE,
-        rawOwner,
-        rawTarget,
-        rawAnchor,
-        rawTags,
-        rawData
-      );
-      const signature = await signData(getPem(jwk), signatureData);
-      bytes.set(signature, 2);
-      const id = hash(signature, "SHA-256");
+    createSoulInstance = (id, name, persona, state, memories = []) => {
+      const soulData = createSoul(id, name, persona, state, memories);
       return {
-        id: import_base64url.default.encode(id),
-        raw: bytes
+        export: (config) => exportSoul(id, soulData, config),
+        toJSON: () => ({ ...soulData })
       };
     };
+    validateSoul = (soul) => {
+      const errors = [
+        !soul.id && "Missing id",
+        !soul.persona && "Missing persona",
+        !soul.state && "Missing state"
+      ].filter((e) => !!e);
+      return { valid: errors.length === 0, errors };
+    };
   }
 });
 
@@ -271,6 +121,7 @@ __export(index_exports, {
   createRemoteCortex: () => createRemoteCortex,
   createSoul: () => createSoul,
   createSoulInstance: () => createSoulInstance,
+  delay: () => delay,
   deserializeSoul: () => deserializeSoul,
   exportSoul: () => exportSoul,
   exportToSoul: () => exportToSoul,
@@ -280,12 +131,18 @@ __export(index_exports, {
   getGhostStatus: () => getGhostStatus,
   getSoulList: () => getSoulList,
   importSoulFromArweave: () => importSoulFromArweave,
-  presets: () => presets_exports,
+  loadPreset: () => loadPreset,
+  memoise: () => memoise,
+  memoiseAsync: () => memoiseAsync,
+  pipe: () => pipe,
   serializeSoul: () => serializeSoul,
   startGhostSession: () => startGhostSession,
   stopGhostSession: () => stopGhostSession,
+  streamFromCortex: () => streamFromCortex,
+  streamFromCortexWithDelay: () => streamFromCortexWithDelay,
+  streamToCallback: () => streamToCallback,
+  streamToString: () => streamToString,
   updateAgentState: () => updateAgentState,
-  uploadToArweave: () => uploadToArweave,
   validateAction: () => validateAction,
   validateSoul: () => validateSoul,
   waitForGhostCompletion: () => waitForGhostCompletion
@@ -293,143 +150,114 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/agent.ts
-var createInitialState = (partial) => {
-  return { ...partial };
-};
-var updateAgentState = (currentState, updates) => {
-  return {
-    ...currentState,
-    ...updates
-  };
-};
-var exportToSoul = (agentId, name, persona, state, memories) => {
-  return {
-    id: agentId,
-    version: "1.0.0",
-    name,
-    persona,
-    memories: [...memories],
-    state: { ...state }
-  };
+var createInitialState = (partial) => ({ ...partial });
+var updateAgentState = (currentState, updates) => ({
+  ...currentState,
+  ...updates
+});
+var exportToSoul = (agentId, name, persona, state, memories) => ({
+  id: agentId,
+  version: "1.0.0",
+  name,
+  persona,
+  memories: [...memories],
+  state: { ...state }
+});
+var storeMemoriesRecursive = async (memory, instructions, index = 0) => {
+  if (index >= instructions.length) return;
+  const { text, type, importance } = instructions[index];
+  await memory.store(text, type, importance).catch((e) => console.warn("Memory store failed:", e));
+  return storeMemoriesRecursive(memory, instructions, index + 1);
 };
 var createAgent = (config) => {
-  let state = createInitialState(config.initialState);
+  let _state = createInitialState(config.initialState);
   const cortex = config.cortex;
   const apiUrl = config.apiUrl || "https://api.forboc.ai";
   const agentId = config.id || "agent-" + Math.random().toString(36).substring(7);
-  const getAgentState = () => {
-    return { ...state };
-  };
-  const setAgentState = (newState) => {
-    state = newState;
+  const authHeaders = config.apiKey ? { "Content-Type": "application/json", "Authorization": `Bearer ${config.apiKey}` } : { "Content-Type": "application/json" };
+  const getState = () => ({ ..._state });
+  const setState = (newState) => {
+    _state = newState;
   };
   const process = async (input, context = {}) => {
-    const currentState = getAgentState();
-    const directiveBody = {
-      observation: input,
-      agentState: currentState,
-      context
-    };
+    const currentState = getState();
     const dirRes = await fetch(`${apiUrl}/agents/${agentId}/directive`, {
       method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(directiveBody)
+      headers: authHeaders,
+      body: JSON.stringify({ observation: input, agentState: currentState, context })
     });
-    if (!dirRes.ok) {
-      throw new Error(`API Directive Error: ${dirRes.status}`);
-    }
+    if (!dirRes.ok) throw new Error(`API Directive Error: ${dirRes.status}`);
     const directiveData = await dirRes.json();
-    let recalledMemories = [];
-    if (config.memory && typeof config.memory.recall === "function") {
-      try {
-        const rawMemories = await config.memory.recall(
-          directiveData.memoryRecall.query,
-          directiveData.memoryRecall.limit,
-          directiveData.memoryRecall.threshold
-        );
-        recalledMemories = rawMemories.map((m) => ({
-          text: m.text,
-          type: m.type,
-          importance: m.importance,
-          similarity: void 0
-        }));
-      } catch (e) {
-        console.warn("Memory recall failed, continuing with empty memories:", e);
-      }
-    }
-    const contextBody = {
-      memories: recalledMemories,
-      observation: input,
-      agentState: currentState
-    };
+    const recalledMemories = config.memory && directiveData.memoryRecall ? await config.memory.recall(
+      directiveData.memoryRecall.query,
+      directiveData.memoryRecall.limit,
+      directiveData.memoryRecall.threshold
+    ).then((mems) => mems.map((m) => ({ text: m.text, type: m.type, importance: m.importance, similarity: void 0 }))).catch(() => []) : [];
     const ctxRes = await fetch(`${apiUrl}/agents/${agentId}/context`, {
       method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(contextBody)
+      headers: authHeaders,
+      body: JSON.stringify({ memories: recalledMemories, observation: input, agentState: currentState })
     });
-    if (!ctxRes.ok) {
-      throw new Error(`API Context Error: ${ctxRes.status}`);
-    }
+    if (!ctxRes.ok) throw new Error(`API Context Error: ${ctxRes.status}`);
     const contextData = await ctxRes.json();
     const generatedText = await cortex.complete(contextData.prompt, {
       maxTokens: contextData.constraints.maxTokens,
       temperature: contextData.constraints.temperature,
       stop: contextData.constraints.stop
     });
-    const verdictBody = {
-      generatedOutput: generatedText,
-      observation: input,
-      agentState: currentState
-    };
     const verRes = await fetch(`${apiUrl}/agents/${agentId}/verdict`, {
       method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(verdictBody)
+      headers: authHeaders,
+      body: JSON.stringify({ generatedOutput: generatedText, observation: input, agentState: currentState })
     });
-    if (!verRes.ok) {
-      throw new Error(`API Verdict Error: ${verRes.status}`);
-    }
+    if (!verRes.ok) throw new Error(`API Verdict Error: ${verRes.status}`);
     const verdictData = await verRes.json();
     if (!verdictData.valid) {
-      return {
-        dialogue: "... [Action Blocked by Protocol]",
-        action: { type: "BLOCKED", reason: "API Validation Failed" }
-      };
+      return { dialogue: "... [Blocked]", action: { type: "BLOCKED", reason: "Validation Failed" } };
     }
-    if (config.memory && typeof config.memory.store === "function" && verdictData.memoryStore) {
-      for (const instruction of verdictData.memoryStore) {
-        config.memory.store(instruction.text, instruction.type, instruction.importance).catch((e) => console.warn("Memory store failed:", e));
-      }
+    if (config.memory && verdictData.memoryStore) {
+      storeMemoriesRecursive(config.memory, verdictData.memoryStore);
     }
-    if (verdictData.stateDelta && Object.keys(verdictData.stateDelta).length > 0) {
-      state = updateAgentState(state, verdictData.stateDelta);
+    if (verdictData.stateDelta) {
+      setState(updateAgentState(_state, verdictData.stateDelta));
     }
     return {
       dialogue: generatedText,
-      action: verdictData.action ? {
-        ...verdictData.action,
-        signature: verdictData.signature
-      } : void 0,
+      action: verdictData.action ? { ...verdictData.action, signature: verdictData.signature } : void 0,
       thought: generatedText
     };
   };
+  const speak = async (message, context = {}) => {
+    const res = await fetch(`${apiUrl}/agents/${agentId}/speak`, {
+      method: "POST",
+      headers: authHeaders,
+      body: JSON.stringify({ speakMessage: message, speakContext: context, speakAgentState: getState() })
+    });
+    if (!res.ok) throw new Error(`API Speak Error: ${res.status}`);
+    const data = await res.json();
+    if (data.speakHistory) setState(updateAgentState(_state, { conversationHistory: data.speakHistory }));
+    return data.speakReply;
+  };
+  const dialogue = async (message, context = []) => {
+    const res = await fetch(`${apiUrl}/agents/${agentId}/dialogue`, {
+      method: "POST",
+      headers: authHeaders,
+      body: JSON.stringify({ diagMessage: message, diagContext: context })
+    });
+    if (!res.ok) throw new Error(`API Dialogue Error: ${res.status}`);
+    const data = await res.json();
+    return data.diagReply;
+  };
   const exportSoul2 = async () => {
-    let exportedMemories = [];
-    if (config.memory && typeof config.memory.export === "function") {
-      try {
-        exportedMemories = await config.memory.export();
-      } catch (e) {
-        console.warn("Memory export failed, exporting with empty memories:", e);
-      }
-    }
-    return exportToSoul(agentId, "Agent", config.persona, state, exportedMemories);
+    const memories = config.memory ? await config.memory.export().catch(() => []) : [];
+    return exportToSoul(agentId, "Agent", config.persona, _state, memories);
   };
-  return {
-    process,
-    getState: getAgentState,
-    setState: setAgentState,
-    export: exportSoul2
+  const exportSoulToArweave = async (soulConfig) => {
+    const soul = await exportSoul2();
+    const { exportSoul: exportFunc } = await Promise.resolve().then(() => (init_soul(), soul_exports));
+    return exportFunc(agentId, soul, { ...soulConfig, apiUrl });
   };
+  return { process, speak, dialogue, reply: speak, getState, setState, export: exportSoul2, exportSoul: exportSoulToArweave };
 };
 var fromSoul = async (soul, cortex, memory) => {
   const agent = createAgent({
@@ -439,412 +267,180 @@ var fromSoul = async (soul, cortex, memory) => {
     persona: soul.persona,
     initialState: soul.state
   });
-  if (memory && soul.memories && soul.memories.length > 0 && typeof memory.import === "function") {
-    try {
-      await memory.import(soul.memories);
-    } catch (e) {
-      console.warn("Memory hydration failed, continuing without memories:", e);
-    }
+  if (memory && soul.memories && soul.memories.length > 0) {
+    await memory.import(soul.memories).catch((e) => console.warn("Memory hydration failed:", e));
   }
   return agent;
 };
 
 // src/bridge.ts
 var createBridge = (config = {}) => {
-  const effectiveConfig = {
-    strictMode: config.strictMode ?? false,
-    ...config
-  };
-  const rules = /* @__PURE__ */ new Map();
-  if (config.customRules) {
-    config.customRules.forEach((rule) => rules.set(rule.id, rule));
-  }
-  const validateRemote = async (action) => {
-    const response = await fetch(`${effectiveConfig.apiUrl}/bridge/validate`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        actionType: action.type,
-        payload: JSON.stringify(action.payload || {})
-      })
-    });
-    if (!response.ok) {
-      throw new Error(`API validation failed: ${response.statusText}`);
-    }
-    const data = await response.json();
-    return {
-      valid: data.valid,
-      reason: data.reason
-    };
-  };
+  const apiUrl = config.apiUrl || "https://api.forboc.ai";
+  const agentId = config.agentId;
   const validate = async (action, context = {}) => {
-    const applicableRules = Array.from(rules.values()).filter(
-      (rule) => rule.actionTypes.some(
-        (t) => t.toLowerCase() === action.type.toLowerCase()
-      )
-    );
-    if (effectiveConfig.strictMode && applicableRules.length === 0) {
-      const safeTypes = ["IDLE", "idle", "WAIT", "wait"];
-      if (!safeTypes.includes(action.type)) {
-        return {
-          valid: false,
-          reason: `Unknown action type '${action.type}' in strict mode`,
-          correctedAction: { ...action, type: "IDLE", reason: "Unknown action type" }
-        };
-      }
-    }
-    let currentAction = action;
-    for (const rule of applicableRules) {
-      const result = rule.validate(currentAction, context);
-      if (!result.valid) {
-        return result;
-      }
-      if (result.correctedAction) {
-        currentAction = result.correctedAction;
+    const endpoint = agentId ? `${apiUrl}/bridge/validate/${agentId}` : `${apiUrl}/bridge/validate`;
+    try {
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ action, context })
+      });
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Bridge validation failed: ${error}`);
       }
+      const data = await response.json();
+      return data.brResult || data;
+    } catch (e) {
+      console.error("[Bridge] Validation error:", e);
+      return {
+        valid: false,
+        reason: `Network error reaching validation API: ${e instanceof Error ? e.message : String(e)}`
+      };
     }
-    return {
-      valid: true,
-      correctedAction: currentAction !== action ? currentAction : void 0
-    };
-  };
-  const registerRule = (rule) => {
-    rules.set(rule.id, rule);
-  };
-  const listRules = () => {
-    return Array.from(rules.values());
   };
-  const removeRule = (ruleId) => {
-    return rules.delete(ruleId);
-  };
-  return {
-    validate,
-    registerRule,
-    listRules,
-    removeRule
+  const listRulesets = async () => {
+    const response = await fetch(`${apiUrl}/rules`);
+    if (!response.ok) return [];
+    return response.json();
   };
+  return { validate, listRulesets };
 };
-var validateAction = (action, rules, context = {}) => {
-  for (const rule of rules) {
-    if (rule.actionTypes.some((t) => t.toLowerCase() === action.type.toLowerCase())) {
-      const result = rule.validate(action, context);
-      if (!result.valid) {
-        return result;
-      }
-    }
+var validateAction = async (action, context = {}, config = {}) => {
+  const bridge = createBridge(config);
+  return bridge.validate(action, context);
+};
+var loadPreset = async (presetName, apiUrl = "https://api.forboc.ai") => {
+  const response = await fetch(`${apiUrl}/rules/presets/${presetName}`, {
+    method: "POST"
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to load preset '${presetName}': ${response.statusText}`);
   }
-  return { valid: true };
+  return response.json();
 };
 
-// src/soul.ts
-var createSoul = (id, name, persona, state, memories = []) => {
-  return {
-    id,
-    version: "1.0.0",
-    name,
-    persona,
-    state: { ...state },
-    memories: [...memories]
+// src/index.ts
+init_soul();
+
+// src/utils.ts
+var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var pipe = (...fns) => (initialValue) => fns.reduce((acc, fn) => fn(acc), initialValue);
+var memoiseAsync = (fn) => {
+  let cached = null;
+  let promise = null;
+  return () => {
+    if (cached) return Promise.resolve(cached);
+    if (promise) return promise;
+    promise = fn().then((value) => {
+      cached = value;
+      return value;
+    });
+    return promise;
   };
 };
-var serializeSoul = (soul) => {
-  return JSON.stringify(soul, null, 2);
+var memoise = (fn) => {
+  let cached = null;
+  let initialized = false;
+  return () => {
+    if (initialized) return cached;
+    cached = fn();
+    initialized = true;
+    return cached;
+  };
 };
-var deserializeSoul = (json) => {
-  const parsed = JSON.parse(json);
-  if (!parsed.id || !parsed.persona || !parsed.state) {
-    throw new Error("Invalid Soul format: missing required fields");
-  }
+
+// src/ghost.ts
+var DEFAULT_API_URL = "https://api.forboc.ai";
+var startGhostSession = async (config) => {
+  const apiUrl = config.apiUrl || DEFAULT_API_URL;
+  const response = await fetch(`${apiUrl}/ghost/run`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      testSuite: config.testSuite,
+      duration: config.duration
+    })
+  });
+  if (!response.ok) throw new Error(`Failed to start Ghost: ${response.statusText}`);
+  const data = await response.json();
   return {
-    id: parsed.id,
-    version: parsed.version || "1.0.0",
-    name: parsed.name || "Unknown",
-    persona: parsed.persona,
-    state: parsed.state,
-    memories: parsed.memories || [],
-    signature: parsed.signature
+    sessionId: data.sessionId,
+    status: data.runStatus
   };
 };
-var uploadToArweave = async (soul, config) => {
-  const wallet = config.walletJwk || config.privateKey;
-  if (!wallet) {
-    throw new Error("Arweave wallet JWK required for direct upload");
-  }
-  let createArweaveDataItem2;
-  try {
-    const imported = await Promise.resolve().then(() => (init_ans104(), ans104_exports));
-    createArweaveDataItem2 = imported.createArweaveDataItem;
-  } catch (e) {
-    throw new Error("Missing ANS-104 Arweave module. Rebuild the SDK to enable direct uploads.");
-  }
-  const jwk = typeof wallet === "string" ? JSON.parse(wallet) : wallet;
-  const dataToUpload = serializeSoul(soul);
-  const tags = [
-    { name: "Content-Type", value: "application/json" },
-    { name: "App-Name", value: "ForbocAI" },
-    { name: "App-Version", value: "soul-1" }
-  ];
-  const dataItem = await createArweaveDataItem2(dataToUpload, jwk, { tags });
-  const rawData = dataItem.raw;
-  if (!rawData) {
-    throw new Error("Failed to build ANS-104 data item");
-  }
-  const bundlerUrl = config.bundlerUrl || "https://upload.ardrive.io/v1/tx";
-  const gatewayUrl = config.gatewayUrl || "https://arweave.net";
-  try {
-    const response = await fetch(bundlerUrl, {
-      method: "POST",
-      headers: { "Content-Type": "application/octet-stream" },
-      body: rawData
-    });
-    if (!response.ok) {
-      const message = await response.text().catch(() => response.statusText);
-      throw new Error(message || response.statusText);
-    }
-    const responseText = await response.text();
-    let responseJson = null;
-    try {
-      responseJson = JSON.parse(responseText);
-    } catch {
-      responseJson = null;
-    }
-    const txId = responseJson?.id || responseJson?.dataItemId || responseJson?.txId || (typeof responseText === "string" && responseText.trim().length > 0 ? responseText.trim() : null) || dataItem.id;
-    if (!txId) {
-      throw new Error("Bundler response did not include a data item id");
-    }
-    return {
-      txId,
-      url: `${gatewayUrl}/${txId}`,
-      soul
-    };
-  } catch (e) {
-    throw new Error(`Failed to upload to Arweave: ${e}`);
-  }
-};
-var exportSoul = async (_agentId, soul, config = {}) => {
-  if (!config.walletJwk && !config.privateKey) {
-    throw new Error("walletJwk required for Arweave ANS-104 export");
-  }
-  return uploadToArweave(soul, config);
-};
-var importSoulFromArweave = async (txId, config = {}) => {
-  const gateway = config.gatewayUrl || "https://arweave.net";
-  try {
-    const response = await fetch(`${gateway}/${txId}`, {
-      method: "GET",
-      headers: { "Content-Type": "application/json" }
-    });
-    if (!response.ok) {
-      throw new Error(`Import failed: ${response.statusText}`);
-    }
-    const data = await response.json();
-    if (!data.id || !data.persona) {
-      throw new Error("Invalid soul data from Arweave");
-    }
-    return data;
-  } catch (e) {
-    throw new Error(`Failed to import Soul from TXID ${txId}: ${e}`);
-  }
-};
-var getSoulList = async (limit = 50, apiUrl) => {
-  const url = apiUrl || "https://api.forboc.ai";
-  try {
-    const response = await fetch(`${url}/souls?limit=${limit}`);
-    if (!response.ok) throw new Error(response.statusText);
-    const data = await response.json();
-    return data.souls.map((s) => {
-      const txId = s.txId || s.soulEntryTxId || s.cid;
-      const name = s.name || s.soulEntryName;
-      const agentId = s.agentId || s.soulEntryAgentId;
-      const exportedAt = s.exportedAt || s.soulEntryExportedAt;
-      const url2 = s.url || s.soulEntryArweaveUrl || `https://arweave.net/${txId}`;
-      return { txId, name, agentId, exportedAt, url: url2 };
-    });
-  } catch (e) {
-    return [];
-  }
-};
-var createSoulInstance = (id, name, persona, state, memories = []) => {
-  const soulData = createSoul(id, name, persona, state, memories);
-  const performExport = async (config) => {
-    return exportSoul(soulData.id, soulData, { ...config });
-  };
+var getGhostStatus = async (sessionId, apiUrl) => {
+  const url = apiUrl || DEFAULT_API_URL;
+  const response = await fetch(`${url}/ghost/${sessionId}/status`, {
+    method: "GET",
+    headers: { "Content-Type": "application/json" }
+  });
+  if (!response.ok) throw new Error(`Failed to get status: ${response.statusText}`);
+  const data = await response.json();
   return {
-    export: performExport,
-    toJSON: () => ({ ...soulData })
+    sessionId: data.ghostSessionId,
+    status: data.ghostStatus,
+    progress: data.ghostProgress,
+    startedAt: data.ghostStartedAt,
+    duration: data.ghostDuration,
+    errors: data.ghostErrors
   };
 };
-var validateSoul = (soul) => {
-  const errors = [];
-  if (!soul.id) errors.push("Missing id");
-  if (!soul.persona) errors.push("Missing persona");
-  if (!soul.state) errors.push("Missing state");
+var getGhostResults = async (sessionId, apiUrl) => {
+  const url = apiUrl || DEFAULT_API_URL;
+  const response = await fetch(`${url}/ghost/${sessionId}/results`, {
+    method: "GET",
+    headers: { "Content-Type": "application/json" }
+  });
+  if (!response.ok) throw new Error(`Failed to get results: ${response.statusText}`);
+  const data = await response.json();
   return {
-    valid: errors.length === 0,
-    errors
+    sessionId: data.resultsSessionId,
+    totalTests: data.resultsTotalTests,
+    passed: data.resultsPassed,
+    failed: data.resultsFailed,
+    skipped: data.resultsSkipped,
+    duration: data.resultsDuration,
+    tests: data.resultsTests.map((t) => ({
+      name: t.testName,
+      passed: t.testPassed,
+      duration: t.testDuration,
+      error: t.testError,
+      screenshot: t.testScreenshot
+    })),
+    coverage: data.resultsCoverage,
+    metrics: Object.fromEntries(data.resultsMetrics || [])
   };
 };
-
-// src/ghost.ts
-var startGhostSession = async (config) => {
-  const apiUrl = config.apiUrl || "https://api.forboc.ai";
-  try {
-    const response = await fetch(`${apiUrl}/ghost/run`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        testSuite: config.testSuite,
-        duration: config.duration
-      })
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to start Ghost session: ${response.statusText}`);
-    }
-    const data = await response.json();
-    return {
-      sessionId: data.sessionId,
-      status: data.runStatus
-    };
-  } catch (e) {
-    const mockId = `ghost_${Date.now()}_${Math.random().toString(36).substring(7)}`;
-    return {
-      sessionId: mockId,
-      status: "running"
-    };
-  }
-};
-var getGhostStatus = async (sessionId, apiUrl) => {
-  const url = apiUrl || "https://api.forboc.ai";
-  try {
-    const response = await fetch(`${url}/ghost/${sessionId}/status`, {
-      method: "GET",
-      headers: { "Content-Type": "application/json" }
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to get Ghost status: ${response.statusText}`);
-    }
-    const data = await response.json();
-    return {
-      sessionId: data.ghostSessionId,
-      status: data.ghostStatus,
-      progress: data.ghostProgress,
-      startedAt: data.ghostStartedAt,
-      duration: data.ghostDuration,
-      errors: data.ghostErrors
-    };
-  } catch (e) {
-    return {
-      sessionId,
-      status: "running",
-      progress: Math.floor(Math.random() * 100),
-      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      duration: 60,
-      errors: 0
-    };
+var pollForCompletion = async (sessionId, pollIntervalMs, timeoutMs, startTime, apiUrl, onProgress) => {
+  if (Date.now() - startTime > timeoutMs) {
+    throw new Error(`Ghost session timed out after ${timeoutMs}ms`);
   }
-};
-var getGhostResults = async (sessionId, apiUrl) => {
-  const url = apiUrl || "https://api.forboc.ai";
   try {
-    const response = await fetch(`${url}/ghost/${sessionId}/results`, {
-      method: "GET",
-      headers: { "Content-Type": "application/json" }
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to get Ghost results: ${response.statusText}`);
-    }
-    const data = await response.json();
-    return {
-      sessionId: data.resultsSessionId,
-      totalTests: data.resultsTotalTests,
-      passed: data.resultsPassed,
-      failed: data.resultsFailed,
-      skipped: data.resultsSkipped,
-      duration: data.resultsDuration,
-      tests: data.resultsTests.map((t) => ({
-        name: t.testName,
-        passed: t.testPassed,
-        duration: t.testDuration,
-        error: t.testError,
-        screenshot: t.testScreenshot
-      })),
-      coverage: data.resultsCoverage,
-      metrics: Object.fromEntries(data.resultsMetrics)
-    };
+    const status = await getGhostStatus(sessionId, apiUrl);
+    if (onProgress) onProgress(status);
+    if (status.status === "completed") return getGhostResults(sessionId, apiUrl);
+    if (status.status === "failed") throw new Error(`Ghost session failed with ${status.errors} errors`);
   } catch (e) {
-    return {
-      sessionId,
-      totalTests: 5,
-      passed: 4,
-      failed: 1,
-      skipped: 0,
-      duration: 1245,
-      tests: [
-        { name: "test.navigation", passed: true, duration: 150 },
-        { name: "test.combat", passed: true, duration: 230 },
-        { name: "test.dialogue", passed: false, duration: 450, error: "Timeout" }
-      ],
-      coverage: 0.75,
-      metrics: {
-        avgFrameRate: 58.5,
-        memoryUsageMB: 512.3,
-        aiDecisionsPerSec: 15.2
-      }
-    };
-  }
-};
-var waitForGhostCompletion = async (sessionId, pollIntervalMs = 5e3, timeoutMs = 3e5, apiUrl, onProgress) => {
-  const startTime = Date.now();
-  while (Date.now() - startTime < timeoutMs) {
-    try {
-      const status = await getGhostStatus(sessionId, apiUrl);
-      if (onProgress) {
-        onProgress(status);
-      }
-      if (status.status === "completed") {
-        return getGhostResults(sessionId, apiUrl);
-      }
-      if (status.status === "failed") {
-        throw new Error(`Ghost session failed with ${status.errors} errors`);
-      }
-    } catch (e) {
-    }
-    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
   }
-  throw new Error(`Ghost session timed out after ${timeoutMs}ms`);
+  await delay(pollIntervalMs);
+  return pollForCompletion(sessionId, pollIntervalMs, timeoutMs, startTime, apiUrl, onProgress);
 };
+var waitForGhostCompletion = (sessionId, pollIntervalMs = 5e3, timeoutMs = 3e5, apiUrl, onProgress) => pollForCompletion(sessionId, pollIntervalMs, timeoutMs, Date.now(), apiUrl, onProgress);
 var stopGhostSession = async (sessionId, apiUrl) => {
-  const url = apiUrl || "https://api.forboc.ai";
+  const url = apiUrl || DEFAULT_API_URL;
   try {
-    const response = await fetch(`${url}/ghost/${sessionId}/stop`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" }
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to stop Ghost session: ${response.statusText}`);
-    }
-    const data = await response.json();
-    return {
-      stopped: true,
-      status: data.status || "stopped"
-    };
+    const response = await fetch(`${url}/ghost/${sessionId}/stop`, { method: "POST" });
+    return { stopped: response.ok };
   } catch (e) {
-    return {
-      stopped: true,
-      status: "stopped"
-    };
+    return { stopped: true };
   }
 };
 var getGhostHistory = async (limit = 10, apiUrl) => {
-  const url = apiUrl || "https://api.forboc.ai";
+  const url = apiUrl || DEFAULT_API_URL;
   try {
-    const response = await fetch(`${url}/ghost/history?limit=${limit}`, {
-      method: "GET",
-      headers: { "Content-Type": "application/json" }
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to get Ghost history: ${response.statusText}`);
-    }
+    const response = await fetch(`${url}/ghost/history?limit=${limit}`);
+    if (!response.ok) return [];
     const data = await response.json();
     return data.sessions.map((s) => ({
       sessionId: s.sessionId,
@@ -859,54 +455,33 @@ var getGhostHistory = async (limit = 10, apiUrl) => {
   }
 };
 var createGhost = (config) => {
-  let sessionId = null;
-  const apiUrl = config.apiUrl || "https://api.forboc.ai";
+  let _sessionId = null;
+  const apiUrl = config.apiUrl || DEFAULT_API_URL;
   const run = async () => {
     const result = await startGhostSession(config);
-    sessionId = result.sessionId;
-    return sessionId;
-  };
-  const status = async () => {
-    if (!sessionId) {
-      throw new Error("Ghost session not started");
-    }
-    return getGhostStatus(sessionId, apiUrl);
+    _sessionId = result.sessionId;
+    return _sessionId;
   };
-  const results = async () => {
-    if (!sessionId) {
-      throw new Error("Ghost session not started");
-    }
-    return getGhostResults(sessionId, apiUrl);
+  const ensureSessionId = () => {
+    if (!_sessionId) throw new Error("Ghost session not started");
+    return _sessionId;
   };
+  const status = async () => getGhostStatus(ensureSessionId(), apiUrl);
+  const results = async () => getGhostResults(ensureSessionId(), apiUrl);
   const stop = async () => {
-    if (sessionId) {
-      await stopGhostSession(sessionId, apiUrl);
-    }
-    sessionId = null;
-  };
-  const waitForCompletion = async (pollIntervalMs, timeoutMs, onProgress) => {
-    if (!sessionId) {
-      throw new Error("Ghost session not started");
-    }
-    return waitForGhostCompletion(
-      sessionId,
-      pollIntervalMs,
-      timeoutMs,
-      apiUrl,
-      onProgress
-    );
-  };
-  return {
-    run,
-    status,
-    results,
-    stop,
-    waitForCompletion
+    if (_sessionId) await stopGhostSession(_sessionId, apiUrl);
+    _sessionId = null;
   };
+  const waitForCompletion = (pollIntervalMs, timeoutMs, onProgress) => waitForGhostCompletion(ensureSessionId(), pollIntervalMs, timeoutMs, apiUrl, onProgress);
+  return { run, status, results, stop, waitForCompletion };
 };
 
 // src/cortex-remote.ts
-var createRemoteCortex = (apiUrl, cortexId = "local") => {
+var createRemoteCortex = (apiUrl, cortexId = "local", apiKey) => {
+  const authHeaders = {
+    "Content-Type": "application/json",
+    ...apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
+  };
   const init = async () => ({
     id: `remote_${Date.now()}`,
     model: "api-integrated",
@@ -916,7 +491,7 @@ var createRemoteCortex = (apiUrl, cortexId = "local") => {
   const complete = async (prompt, options) => {
     const response = await fetch(`${apiUrl}/cortex/${cortexId}/complete`, {
       method: "POST",
-      headers: { "Content-Type": "application/json" },
+      headers: authHeaders,
       body: JSON.stringify({ prompt, ...options })
     });
     if (!response.ok) throw new Error(`Remote Cortex failed: ${response.statusText}`);
@@ -930,214 +505,32 @@ var createRemoteCortex = (apiUrl, cortexId = "local") => {
   return { init, complete, completeStream };
 };
 
-// src/presets/index.ts
-var presets_exports = {};
-__export(presets_exports, {
-  RPG_MEMORY_TYPES: () => RPG_MEMORY_TYPES,
-  RPG_MOODS: () => RPG_MOODS,
-  attackRule: () => attackRule,
-  createRPGState: () => createRPGState,
-  interactRule: () => interactRule,
-  movementRule: () => movementRule,
-  puzzleRules: () => puzzleRules,
-  resourceRule: () => resourceRule,
-  rpgRules: () => rpgRules,
-  socialRules: () => socialRules,
-  spatialRules: () => spatialRules,
-  speakRule: () => speakRule
-});
-
-// src/presets/rpg.ts
-var RPG_MOODS = {
-  hostile: "hostile",
-  suspicious: "suspicious",
-  neutral: "neutral",
-  friendly: "friendly",
-  loyal: "loyal"
-};
-var RPG_MEMORY_TYPES = {
-  observation: "observation",
-  experience: "experience",
-  knowledge: "knowledge",
-  emotion: "emotion"
-};
-var createRPGState = (partial) => {
-  return {
-    inventory: partial?.inventory ?? [],
-    hp: partial?.hp ?? 100,
-    mana: partial?.mana ?? 100,
-    skills: partial?.skills ?? {},
-    relationships: partial?.relationships ?? {},
-    mood: partial?.mood ?? "neutral",
-    ...partial
-  };
-};
-var movementRule = {
-  id: "core.movement",
-  name: "Movement Validation",
-  description: "Ensures MOVE actions have valid x,y coordinates",
-  actionTypes: ["MOVE", "move"],
-  validate: (action, context) => {
-    const payload = action.payload || {};
-    const target = payload.target;
-    if (!target || typeof target.x !== "number" || typeof target.y !== "number") {
-      return {
-        valid: false,
-        reason: "MOVE action must have target with numeric x,y coordinates",
-        correctedAction: {
-          ...action,
-          type: "IDLE",
-          reason: "Invalid MOVE target - defaulting to IDLE"
-        }
-      };
-    }
-    const world = context.worldState || {};
-    const maxX = world.maxX || Infinity;
-    const maxY = world.maxY || Infinity;
-    if (target.x < 0 || target.x > maxX || target.y < 0 || target.y > maxY) {
-      return {
-        valid: false,
-        reason: `MOVE target (${target.x}, ${target.y}) is out of bounds`,
-        correctedAction: {
-          ...action,
-          payload: {
-            ...payload,
-            target: {
-              x: Math.max(0, Math.min(maxX, target.x)),
-              y: Math.max(0, Math.min(maxY, target.y))
-            }
-          }
-        }
-      };
-    }
-    return { valid: true };
-  }
-};
-var attackRule = {
-  id: "core.attack",
-  name: "Attack Validation",
-  description: "Ensures ATTACK actions have valid targetId",
-  actionTypes: ["ATTACK", "attack"],
-  validate: (action, context) => {
-    if (!action.target && !action.payload?.targetId) {
-      return {
-        valid: false,
-        reason: "ATTACK action must have a target or targetId",
-        correctedAction: {
-          ...action,
-          type: "IDLE",
-          reason: "Invalid ATTACK - no target specified"
-        }
-      };
-    }
-    const world = context.worldState || {};
-    const entities = world.entities || [];
-    const targetId = action.target || action.payload?.targetId;
-    if (entities.length > 0 && !entities.includes(targetId)) {
-      return {
-        valid: false,
-        reason: `ATTACK target '${targetId}' does not exist in world`,
-        correctedAction: {
-          ...action,
-          type: "IDLE",
-          reason: "Target not found"
-        }
-      };
-    }
-    return { valid: true };
-  }
-};
-var interactRule = {
-  id: "core.interact",
-  name: "Interact Validation",
-  description: "Ensures INTERACT actions have valid objectId",
-  actionTypes: ["INTERACT", "interact"],
-  validate: (action, context) => {
-    if (!action.target && !action.payload?.objectId) {
-      return {
-        valid: false,
-        reason: "INTERACT action must have objectId",
-        correctedAction: {
-          ...action,
-          type: "IDLE",
-          reason: "Invalid INTERACT - no object specified"
-        }
-      };
-    }
-    return { valid: true };
-  }
+// src/stream.ts
+var consumeStream = async (stream, onChunk, acc = "", delayMs = 0) => {
+  const { value, done } = await stream.next();
+  if (done) return acc;
+  const chunk = value ?? "";
+  onChunk(chunk);
+  if (delayMs > 0) await delay(delayMs);
+  return consumeStream(stream, onChunk, acc + chunk, delayMs);
+};
+var streamToCallback = async (stream, onChunk) => {
+  await consumeStream(stream, onChunk);
+};
+var streamToString = async (stream) => {
+  return consumeStream(stream, () => {
+  });
 };
-var speakRule = {
-  id: "core.speak",
-  name: "Speak Validation",
-  description: "Ensures SPEAK actions have non-empty text",
-  actionTypes: ["SPEAK", "speak"],
-  validate: (action, context) => {
-    const text = action.payload?.text;
-    if (!text || text.trim().length === 0) {
-      return {
-        valid: false,
-        reason: "SPEAK action must have non-empty text",
-        correctedAction: {
-          ...action,
-          type: "IDLE",
-          reason: "Empty speech - defaulting to IDLE"
-        }
-      };
-    }
-    const maxLength = context.constraints?.maxSpeechLength || 1e3;
-    if (text.length > maxLength) {
-      return {
-        valid: true,
-        reason: `Speech truncated to ${maxLength} characters`,
-        correctedAction: {
-          ...action,
-          payload: {
-            ...action.payload,
-            text: text.substring(0, maxLength)
-          }
-        }
-      };
-    }
-    return { valid: true };
-  }
+var streamFromCortex = async (cortex, prompt, onChunk, options) => {
+  return consumeStream(cortex.completeStream(prompt, options), onChunk);
 };
-var resourceRule = {
-  id: "core.resources",
-  name: "Resource Validation",
-  description: "Ensures agent has required resources for action",
-  actionTypes: ["ATTACK", "CAST", "USE_ITEM"],
-  validate: (action, context) => {
-    const agent = context.agentState || {};
-    const hp = agent.hp ?? 100;
-    const mana = agent.mana ?? 100;
-    if (hp <= 0) {
-      return {
-        valid: false,
-        reason: "Agent is dead and cannot perform actions",
-        correctedAction: { ...action, type: "IDLE", reason: "Agent dead" }
-      };
-    }
-    if (action.type === "CAST" || action.type === "cast") {
-      const manaCost = action.payload?.manaCost || 10;
-      if (mana < manaCost) {
-        return {
-          valid: false,
-          reason: `Insufficient mana: need ${manaCost}, have ${mana}`,
-          correctedAction: { ...action, type: "IDLE", reason: "Not enough mana" }
-        };
-      }
-    }
-    return { valid: true };
-  }
+var streamFromCortexWithDelay = async (cortex, prompt, onChunk, options) => {
+  const { delayMs = 30, ...completionOptions } = options ?? {};
+  return consumeStream(cortex.completeStream(prompt, completionOptions), onChunk, "", delayMs);
 };
-var rpgRules = [movementRule, attackRule, interactRule, speakRule, resourceRule];
-var spatialRules = [movementRule];
-var socialRules = [speakRule, interactRule];
-var puzzleRules = [movementRule, interactRule];
 
 // src/index.ts
-var SDK_VERSION = "0.5.6";
+var SDK_VERSION = "0.5.7";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   SDK_VERSION,
@@ -1148,6 +541,7 @@ var SDK_VERSION = "0.5.6";
   createRemoteCortex,
   createSoul,
   createSoulInstance,
+  delay,
   deserializeSoul,
   exportSoul,
   exportToSoul,
@@ -1157,12 +551,18 @@ var SDK_VERSION = "0.5.6";
   getGhostStatus,
   getSoulList,
   importSoulFromArweave,
-  presets,
+  loadPreset,
+  memoise,
+  memoiseAsync,
+  pipe,
   serializeSoul,
   startGhostSession,
   stopGhostSession,
+  streamFromCortex,
+  streamFromCortexWithDelay,
+  streamToCallback,
+  streamToString,
   updateAgentState,
-  uploadToArweave,
   validateAction,
   validateSoul,
   waitForGhostCompletion