@forbocai/core 0.5.8 → 0.6.0

package/dist/index.js

@@ -3,9 +3,6 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -20,310 +17,598 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// 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 createSoul, serializeSoul, deserializeSoul, exportSoul, importSoulFromArweave, getSoulList, createSoulInstance, validateSoul;
-var init_soul = __esm({
-  "src/soul.ts"() {
-    "use strict";
-    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");
-      }
-      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
-      };
-    };
-    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
-      };
-    };
-    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;
-    };
-    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 || [];
-    };
-    createSoulInstance = (id, name, persona, state, memories = []) => {
-      const soulData = createSoul(id, name, persona, state, memories);
-      return {
-        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 };
-    };
-  }
-});
-
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
   SDK_VERSION: () => SDK_VERSION,
-  createAgent: () => createAgent,
-  createBridge: () => createBridge,
-  createGhost: () => createGhost,
+  addToHistory: () => addToHistory,
+  blockAction: () => blockAction,
+  bridgeSlice: () => bridgeSlice,
+  clearBlock: () => clearBlock,
+  clearBridgeValidation: () => clearBridgeValidation,
+  clearGhostSession: () => clearGhostSession,
+  clearSoulState: () => clearSoulState,
+  completeRemoteThunk: () => completeRemoteThunk,
+  cortexInitFailed: () => cortexInitFailed,
+  cortexInitStart: () => cortexInitStart,
+  cortexInitSuccess: () => cortexInitSuccess,
+  cortexSlice: () => cortexSlice,
   createInitialState: () => createInitialState,
-  createRemoteCortex: () => createRemoteCortex,
-  createSoul: () => createSoul,
-  createSoulInstance: () => createSoulInstance,
+  createSDKStore: () => createSDKStore,
   delay: () => delay,
-  deserializeSoul: () => deserializeSoul,
-  exportSoul: () => exportSoul,
+  dialogueNPC: () => dialogueNPC,
+  dispatch: () => dispatch,
   exportToSoul: () => exportToSoul,
-  fromSoul: () => fromSoul,
-  getGhostHistory: () => getGhostHistory,
-  getGhostResults: () => getGhostResults,
-  getGhostStatus: () => getGhostStatus,
-  getSoulList: () => getSoulList,
-  importSoulFromArweave: () => importSoulFromArweave,
-  loadPreset: () => loadPreset,
+  generateNPCId: () => generateNPCId,
+  getBridgeRulesThunk: () => getBridgeRulesThunk,
+  getGhostHistoryThunk: () => getGhostHistoryThunk,
+  getGhostResultsThunk: () => getGhostResultsThunk,
+  getGhostStatusThunk: () => getGhostStatusThunk,
+  getSoulListThunk: () => getSoulListThunk,
+  ghostSlice: () => ghostSlice,
+  importSoulFromArweaveThunk: () => importSoulFromArweaveThunk,
+  initRemoteCortexThunk: () => initRemoteCortexThunk,
+  loadBridgePresetThunk: () => loadBridgePresetThunk,
+  localExportSoulThunk: () => localExportSoulThunk,
   memoise: () => memoise,
   memoiseAsync: () => memoiseAsync,
+  memoryClear: () => memoryClear,
+  memoryRecallFailed: () => memoryRecallFailed,
+  memoryRecallStart: () => memoryRecallStart,
+  memoryRecallSuccess: () => memoryRecallSuccess,
+  memorySlice: () => memorySlice,
+  memoryStoreFailed: () => memoryStoreFailed,
+  memoryStoreStart: () => memoryStoreStart,
+  memoryStoreSuccess: () => memoryStoreSuccess,
+  npcSlice: () => npcSlice,
   pipe: () => pipe,
-  serializeSoul: () => serializeSoul,
-  startGhostSession: () => startGhostSession,
-  stopGhostSession: () => stopGhostSession,
+  processNPC: () => processNPC,
+  remoteExportSoulThunk: () => remoteExportSoulThunk,
+  removeNPC: () => removeNPC,
+  sdkApi: () => sdkApi,
+  selectActiveNPC: () => selectActiveNPC,
+  selectActiveNpcId: () => selectActiveNpcId,
+  selectAllMemories: () => selectAllMemories,
+  selectAllNPCs: () => selectAllNPCs,
+  selectLastRecalledMemories: () => selectLastRecalledMemories,
+  selectMemoryById: () => selectMemoryById,
+  selectNPCById: () => selectNPCById,
+  selectNPCEntities: () => selectNPCEntities,
+  selectNPCIds: () => selectNPCIds,
+  selectTotalNPCs: () => selectTotalNPCs,
+  setActiveNPC: () => setActiveNPC,
+  setCortexStatus: () => setCortexStatus,
+  setHistory: () => setHistory,
+  setLastAction: () => setLastAction,
+  setNPCInfo: () => setNPCInfo,
+  setNPCState: () => setNPCState,
+  soulSlice: () => soulSlice,
+  speakNPC: () => speakNPC,
+  startGhostThunk: () => startGhostThunk,
+  stopGhostThunk: () => stopGhostThunk,
+  store: () => store,
   streamFromCortex: () => streamFromCortex,
   streamFromCortexWithDelay: () => streamFromCortexWithDelay,
   streamToCallback: () => streamToCallback,
   streamToString: () => streamToString,
-  updateAgentState: () => updateAgentState,
-  validateAction: () => validateAction,
-  validateSoul: () => validateSoul,
-  waitForGhostCompletion: () => waitForGhostCompletion
+  updateNPCState: () => updateNPCState,
+  updateNPCStateLocally: () => updateNPCStateLocally,
+  validateBridgeThunk: () => validateBridgeThunk
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/agent.ts
+// src/npc.ts
 var createInitialState = (partial) => ({ ...partial });
-var updateAgentState = (currentState, updates) => ({
+var updateNPCStateLocally = (currentState, updates) => ({
   ...currentState,
   ...updates
 });
-var exportToSoul = (agentId, name, persona, state, memories) => ({
-  id: agentId,
+var exportToSoul = (npcId, name, persona, state, memories) => ({
+  id: npcId,
   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);
+
+// src/bridgeSlice.ts
+var import_toolkit = require("@reduxjs/toolkit");
+
+// src/apiSlice.ts
+var import_query = require("@reduxjs/toolkit/query");
+var sdkApi = (0, import_query.createApi)({
+  reducerPath: "forbocApi",
+  baseQuery: (0, import_query.fetchBaseQuery)({
+    baseUrl: "/",
+    prepareHeaders: (headers, { getState }) => {
+      return headers;
+    }
+  }),
+  tagTypes: ["NPC", "Memory", "Cortex", "Ghost", "Soul", "Bridge"],
+  endpoints: (builder) => ({
+    // NPC Endpoints
+    postDirective: builder.mutation({
+      query: ({ npcId, request, apiUrl, apiKey }) => ({
+        url: `${apiUrl}/npcs/${npcId}/directive`,
+        method: "POST",
+        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
+        body: request
+      }),
+      invalidatesTags: ["NPC"],
+      transformResponse: (response) => response
+    }),
+    postContext: builder.mutation({
+      query: ({ npcId, request, apiUrl, apiKey }) => ({
+        url: `${apiUrl}/npcs/${npcId}/context`,
+        method: "POST",
+        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
+        body: request
+      }),
+      invalidatesTags: (result, error, { npcId }) => [{ type: "NPC", id: npcId }],
+      transformResponse: (response) => response
+    }),
+    postVerdict: builder.mutation({
+      query: ({ npcId, request, apiUrl, apiKey }) => ({
+        url: `${apiUrl}/npcs/${npcId}/verdict`,
+        method: "POST",
+        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
+        body: request
+      }),
+      invalidatesTags: (result, error, { npcId }) => [{ type: "NPC", id: npcId }],
+      transformResponse: (response) => {
+        const action = response.action ? {
+          type: response.action.gaType || response.action.type,
+          reason: response.action.actionReason || response.action.reason,
+          target: response.action.actionTarget || response.action.target,
+          signature: response.action.signature
+        } : void 0;
+        return {
+          ...response,
+          action
+        };
+      }
+    }),
+    postSpeak: builder.mutation({
+      query: ({ npcId, request, apiUrl, apiKey }) => ({
+        url: `${apiUrl}/npcs/${npcId}/speak`,
+        method: "POST",
+        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
+        body: request
+      }),
+      invalidatesTags: (result, error, { npcId }) => [{ type: "NPC", id: npcId }],
+      transformResponse: (response) => response
+    }),
+    postDialogue: builder.mutation({
+      query: ({ npcId, request, apiUrl, apiKey }) => ({
+        url: `${apiUrl}/npcs/${npcId}/dialogue`,
+        method: "POST",
+        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
+        body: request
+      }),
+      invalidatesTags: (result, error, { npcId }) => [{ type: "NPC", id: npcId }],
+      transformResponse: (response) => response
+    }),
+    // Ghost Endpoints
+    postGhostRun: builder.mutation({
+      query: ({ request, apiUrl }) => ({ url: `${apiUrl}/ghost/run`, method: "POST", body: request }),
+      invalidatesTags: ["Ghost"],
+      transformResponse: (response) => response
+    }),
+    getGhostStatus: builder.query({
+      query: ({ sessionId, apiUrl }) => ({ url: `${apiUrl}/ghost/${sessionId}/status`, method: "GET" }),
+      providesTags: (result, error, { sessionId }) => [{ type: "Ghost", id: sessionId }],
+      transformResponse: (response) => response
+    }),
+    getGhostResults: builder.query({
+      query: ({ sessionId, apiUrl }) => ({ url: `${apiUrl}/ghost/${sessionId}/results`, method: "GET" }),
+      providesTags: (result, error, { sessionId }) => [{ type: "Ghost", id: sessionId }],
+      transformResponse: (response) => response
+    }),
+    postGhostStop: builder.mutation({
+      query: ({ sessionId, apiUrl }) => ({ url: `${apiUrl}/ghost/${sessionId}/stop`, method: "POST" }),
+      invalidatesTags: (result, error, { sessionId }) => [{ type: "Ghost", id: sessionId }],
+      transformResponse: (response) => ({ stopped: true })
+    }),
+    getGhostHistory: builder.query({
+      query: ({ limit, apiUrl }) => ({ url: `${apiUrl}/ghost/history?limit=${limit}`, method: "GET" }),
+      providesTags: ["Ghost"],
+      transformResponse: (response) => response
+    }),
+    // Soul Endpoints
+    postSoulExport: builder.mutation({
+      query: ({ npcId, request, apiUrl }) => ({ url: `${apiUrl}/npcs/${npcId}/soul/export`, method: "POST", body: request }),
+      invalidatesTags: ["Soul"],
+      transformResponse: (response) => response
+    }),
+    getSoulImport: builder.query({
+      query: ({ txId, apiUrl }) => ({ url: `${apiUrl}/souls/${txId}`, method: "GET" }),
+      providesTags: (result, error, { txId }) => [{ type: "Soul", id: txId }],
+      transformResponse: (response) => response
+    }),
+    getSouls: builder.query({
+      query: ({ limit, apiUrl }) => ({ url: `${apiUrl}/souls?limit=${limit}`, method: "GET" }),
+      providesTags: ["Soul"],
+      transformResponse: (response) => response
+    }),
+    // Bridge Endpoints
+    postBridgeValidate: builder.mutation({
+      query: ({ request, npcId, apiUrl }) => ({
+        url: npcId ? `${apiUrl}/bridge/validate/${npcId}` : `${apiUrl}/bridge/validate`,
+        method: "POST",
+        body: request
+      }),
+      invalidatesTags: ["Bridge"],
+      transformResponse: (response) => response.brResult || response
+    }),
+    getBridgeRules: builder.query({
+      query: ({ apiUrl }) => ({ url: `${apiUrl}/rules`, method: "GET" }),
+      providesTags: ["Bridge"],
+      transformResponse: (response) => response
+    }),
+    postBridgePreset: builder.mutation({
+      query: ({ presetName, apiUrl }) => ({ url: `${apiUrl}/rules/presets/${presetName}`, method: "POST" }),
+      invalidatesTags: ["Bridge"],
+      transformResponse: (response) => response
+    }),
+    // Cortex Remote Endpoint
+    postCortexComplete: builder.mutation({
+      query: ({ cortexId, prompt, options, apiUrl, apiKey }) => ({
+        url: `${apiUrl}/cortex/${cortexId}/complete`,
+        method: "POST",
+        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
+        body: { prompt, ...options }
+      }),
+      invalidatesTags: ["Cortex"],
+      transformResponse: (response) => response
+    }),
+    // System Endpoints
+    getApiStatus: builder.query({
+      query: ({ apiUrl }) => ({ url: `${apiUrl}/status`, method: "GET" }),
+      transformResponse: (response) => response
+    })
+  })
+});
+
+// src/bridgeSlice.ts
+var initialState = {
+  activePresets: [],
+  lastValidation: null,
+  status: "idle",
+  error: null
 };
-var createAgent = (config) => {
-  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 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 = getState();
-    const dirRes = await fetch(`${apiUrl}/agents/${agentId}/directive`, {
-      method: "POST",
-      headers: authHeaders,
-      body: JSON.stringify({ observation: input, agentState: currentState, context })
-    });
-    if (!dirRes.ok) throw new Error(`API Directive Error: ${dirRes.status}`);
-    const directiveData = await dirRes.json();
-    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: authHeaders,
-      body: JSON.stringify({ memories: recalledMemories, observation: input, agentState: currentState })
-    });
-    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 verRes = await fetch(`${apiUrl}/agents/${agentId}/verdict`, {
-      method: "POST",
-      headers: authHeaders,
-      body: JSON.stringify({ generatedOutput: generatedText, observation: input, agentState: currentState })
-    });
-    if (!verRes.ok) throw new Error(`API Verdict Error: ${verRes.status}`);
-    const verdictData = await verRes.json();
-    if (!verdictData.valid) {
-      return { dialogue: "... [Blocked]", action: { type: "BLOCKED", reason: "Validation Failed" } };
+var validateBridgeThunk = (0, import_toolkit.createAsyncThunk)(
+  "bridge/validate",
+  async ({ action, context, npcId, apiUrl }, { dispatch: dispatch2, rejectWithValue }) => {
+    try {
+      const url = apiUrl || "https://api.forboc.ai";
+      const data = await dispatch2(sdkApi.endpoints.postBridgeValidate.initiate({
+        request: { action, context },
+        npcId,
+        apiUrl: url
+      })).unwrap();
+      return data;
+    } catch (e) {
+      return rejectWithValue(e.message || "Bridge validation failed");
     }
-    if (config.memory && verdictData.memoryStore) {
-      storeMemoriesRecursive(config.memory, verdictData.memoryStore);
+  }
+);
+var loadBridgePresetThunk = (0, import_toolkit.createAsyncThunk)(
+  "bridge/loadPreset",
+  async ({ presetName, apiUrl }, { dispatch: dispatch2, rejectWithValue }) => {
+    try {
+      const url = apiUrl || "https://api.forboc.ai";
+      return await dispatch2(sdkApi.endpoints.postBridgePreset.initiate({ presetName, apiUrl: url })).unwrap();
+    } catch (e) {
+      return rejectWithValue(e.message || "Failed to load preset");
     }
-    if (verdictData.stateDelta) {
-      setState(updateAgentState(_state, verdictData.stateDelta));
+  }
+);
+var getBridgeRulesThunk = (0, import_toolkit.createAsyncThunk)(
+  "bridge/rules",
+  async ({ apiUrl }, { dispatch: dispatch2, rejectWithValue }) => {
+    try {
+      const url = apiUrl || "https://api.forboc.ai";
+      return await dispatch2(sdkApi.endpoints.getBridgeRules.initiate({ apiUrl: url })).unwrap();
+    } catch (e) {
+      return rejectWithValue(e.message || "Failed to list rulesets");
     }
-    return {
-      dialogue: generatedText,
-      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 })
+  }
+);
+var bridgeSlice = (0, import_toolkit.createSlice)({
+  name: "bridge",
+  initialState,
+  reducers: {
+    clearBridgeValidation: (state) => {
+      state.lastValidation = null;
+      state.status = "idle";
+      state.error = null;
+    }
+  },
+  extraReducers: (builder) => {
+    builder.addCase(validateBridgeThunk.pending, (state) => {
+      state.status = "validating";
+      state.error = null;
+    }).addCase(validateBridgeThunk.fulfilled, (state, action) => {
+      state.status = "idle";
+      state.lastValidation = action.payload;
+    }).addCase(validateBridgeThunk.rejected, (state, action) => {
+      state.status = "error";
+      state.error = action.payload;
+      state.lastValidation = { valid: false, reason: action.payload };
+    }).addCase(loadBridgePresetThunk.pending, (state) => {
+      state.status = "loading_preset";
+      state.error = null;
+    }).addCase(loadBridgePresetThunk.fulfilled, (state, action) => {
+      state.status = "idle";
+      if (!state.activePresets.find((p) => p.id === action.payload.id)) {
+        state.activePresets.push(action.payload);
+      }
+    }).addCase(loadBridgePresetThunk.rejected, (state, action) => {
+      state.status = "error";
+      state.error = action.payload;
+    }).addCase(getBridgeRulesThunk.fulfilled, (state, action) => {
     });
-    if (!res.ok) throw new Error(`API Dialogue Error: ${res.status}`);
-    const data = await res.json();
-    return data.diagReply;
-  };
-  const exportSoul2 = async () => {
-    const memories = config.memory ? await config.memory.export().catch(() => []) : [];
-    return exportToSoul(agentId, "Agent", config.persona, _state, memories);
-  };
-  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({
-    id: soul.id,
-    cortex,
-    memory: memory || null,
-    persona: soul.persona,
-    initialState: soul.state
-  });
-  if (memory && soul.memories && soul.memories.length > 0) {
-    await memory.import(soul.memories).catch((e) => console.warn("Memory hydration failed:", e));
   }
-  return agent;
+});
+var { clearBridgeValidation } = bridgeSlice.actions;
+var bridgeSlice_default = bridgeSlice.reducer;
+
+// src/soulSlice.ts
+var import_toolkit2 = require("@reduxjs/toolkit");
+var initialState2 = {
+  exportStatus: "idle",
+  importStatus: "idle",
+  lastExport: null,
+  lastImport: null,
+  availableSouls: [],
+  error: null
 };
+var remoteExportSoulThunk = (0, import_toolkit2.createAsyncThunk)(
+  "soul/export",
+  async ({ npcId: argNpcId, apiUrl, memories = [] }, { getState, dispatch: dispatch2, rejectWithValue }) => {
+    try {
+      const state = getState().npc;
+      const npcId = argNpcId || state.activeNpcId;
+      const npc = state.entities[npcId];
+      if (!npc) throw new Error(`NPC ${npcId} not found`);
+      const url = apiUrl || "https://api.forboc.ai";
+      const result = await dispatch2(sdkApi.endpoints.postSoulExport.initiate({
+        npcId,
+        request: { npcIdRef: npcId, persona: npc.persona || "NPC", npcState: npc.state },
+        apiUrl: url
+      })).unwrap();
+      return {
+        txId: result.txId,
+        url: result.arweaveUrl,
+        soul: result.soul
+      };
+    } catch (e) {
+      return rejectWithValue(e.message || "Soul export failed");
+    }
+  }
+);
+var importSoulFromArweaveThunk = (0, import_toolkit2.createAsyncThunk)(
+  "soul/import",
+  async ({ txId, apiUrl }, { dispatch: dispatch2, rejectWithValue }) => {
+    try {
+      const url = apiUrl || "https://api.forboc.ai";
+      const data = await dispatch2(sdkApi.endpoints.getSoulImport.initiate({ txId, apiUrl: url })).unwrap();
+      return data;
+    } catch (e) {
+      return rejectWithValue(e.message || "Soul import failed");
+    }
+  }
+);
+var getSoulListThunk = (0, import_toolkit2.createAsyncThunk)(
+  "soul/list",
+  async ({ limit = 50, apiUrl }, { dispatch: dispatch2, rejectWithValue }) => {
+    try {
+      const url = apiUrl || "https://api.forboc.ai";
+      const data = await dispatch2(sdkApi.endpoints.getSouls.initiate({ limit, apiUrl: url })).unwrap();
+      return data.souls || [];
+    } catch (e) {
+      return rejectWithValue(e.message || "Failed to list souls");
+    }
+  }
+);
+var soulSlice = (0, import_toolkit2.createSlice)({
+  name: "soul",
+  initialState: initialState2,
+  reducers: {
+    clearSoulState: (state) => {
+      state.exportStatus = "idle";
+      state.importStatus = "idle";
+      state.lastExport = null;
+      state.lastImport = null;
+      state.error = null;
+    }
+  },
+  extraReducers: (builder) => {
+    builder.addCase(remoteExportSoulThunk.pending, (state) => {
+      state.exportStatus = "exporting";
+      state.error = null;
+    }).addCase(remoteExportSoulThunk.fulfilled, (state, action) => {
+      state.exportStatus = "success";
+      state.lastExport = action.payload;
+    }).addCase(remoteExportSoulThunk.rejected, (state, action) => {
+      state.exportStatus = "failed";
+      state.error = action.payload;
+    }).addCase(importSoulFromArweaveThunk.pending, (state) => {
+      state.importStatus = "importing";
+      state.error = null;
+    }).addCase(importSoulFromArweaveThunk.fulfilled, (state, action) => {
+      state.importStatus = "success";
+      state.lastImport = action.payload;
+    }).addCase(importSoulFromArweaveThunk.rejected, (state, action) => {
+      state.importStatus = "failed";
+      state.error = action.payload;
+    }).addCase(getSoulListThunk.fulfilled, (state, action) => {
+      state.availableSouls = action.payload;
+    });
+  }
+});
+var { clearSoulState } = soulSlice.actions;
+var soulSlice_default = soulSlice.reducer;
 
-// src/bridge.ts
-var createBridge = (config = {}) => {
-  const apiUrl = config.apiUrl || "https://api.forboc.ai";
-  const agentId = config.agentId;
-  const validate = async (action, context = {}) => {
-    const endpoint = agentId ? `${apiUrl}/bridge/validate/${agentId}` : `${apiUrl}/bridge/validate`;
+// src/ghostSlice.ts
+var import_toolkit3 = require("@reduxjs/toolkit");
+var initialState3 = {
+  activeSessionId: null,
+  status: null,
+  progress: 0,
+  results: null,
+  history: [],
+  loading: false,
+  error: null
+};
+var startGhostThunk = (0, import_toolkit3.createAsyncThunk)(
+  "ghost/start",
+  async (config, { dispatch: dispatch2, rejectWithValue }) => {
     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;
+      const apiUrl = config.apiUrl || "https://api.forboc.ai";
+      const data = await dispatch2(sdkApi.endpoints.postGhostRun.initiate({
+        request: { testSuite: config.testSuite, duration: config.duration ?? 300 },
+        apiUrl
+      })).unwrap();
+      return {
+        sessionId: data.sessionId,
+        status: data.runStatus
+      };
     } catch (e) {
-      console.error("[Bridge] Validation error:", e);
+      return rejectWithValue(e.message || "Failed to start Ghost");
+    }
+  }
+);
+var getGhostStatusThunk = (0, import_toolkit3.createAsyncThunk)(
+  "ghost/status",
+  async ({ sessionId, apiUrl }, { dispatch: dispatch2, getState, rejectWithValue }) => {
+    try {
+      const state = getState().ghost;
+      const targetSession = sessionId || state.activeSessionId;
+      if (!targetSession) throw new Error("No active Ghost session");
+      const url = apiUrl || "https://api.forboc.ai";
+      const data = await dispatch2(sdkApi.endpoints.getGhostStatus.initiate({ sessionId: targetSession, apiUrl: url })).unwrap();
       return {
-        valid: false,
-        reason: `Network error reaching validation API: ${e instanceof Error ? e.message : String(e)}`
+        sessionId: data.ghostSessionId,
+        status: data.ghostStatus,
+        progress: data.ghostProgress,
+        startedAt: data.ghostStartedAt,
+        duration: data.ghostDuration || 0,
+        errors: data.ghostErrors
       };
+    } catch (e) {
+      return rejectWithValue(e.message || "Failed to get ghost status");
     }
-  };
-  const listRulesets = async () => {
-    const response = await fetch(`${apiUrl}/rules`);
-    if (!response.ok) return [];
-    return response.json();
-  };
-  return { validate, listRulesets };
-};
-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 response.json();
-};
-
-// src/index.ts
-init_soul();
+);
+var getGhostResultsThunk = (0, import_toolkit3.createAsyncThunk)(
+  "ghost/results",
+  async ({ sessionId, apiUrl }, { dispatch: dispatch2, getState, rejectWithValue }) => {
+    try {
+      const state = getState().ghost;
+      const targetSession = sessionId || state.activeSessionId;
+      if (!targetSession) throw new Error("No active Ghost session");
+      const url = apiUrl || "https://api.forboc.ai";
+      const data = await dispatch2(sdkApi.endpoints.getGhostResults.initiate({ sessionId: targetSession, apiUrl: url })).unwrap();
+      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 || [])
+      };
+    } catch (e) {
+      return rejectWithValue(e.message || "Failed to get ghost results");
+    }
+  }
+);
+var stopGhostThunk = (0, import_toolkit3.createAsyncThunk)(
+  "ghost/stop",
+  async ({ sessionId, apiUrl }, { dispatch: dispatch2, getState, rejectWithValue }) => {
+    try {
+      const state = getState().ghost;
+      const targetSession = sessionId || state.activeSessionId;
+      if (!targetSession) throw new Error("No active Ghost session");
+      const url = apiUrl || "https://api.forboc.ai";
+      await dispatch2(sdkApi.endpoints.postGhostStop.initiate({ sessionId: targetSession, apiUrl: url })).unwrap();
+      return { stopped: true };
+    } catch (e) {
+      return { stopped: true };
+    }
+  }
+);
+var getGhostHistoryThunk = (0, import_toolkit3.createAsyncThunk)(
+  "ghost/history",
+  async ({ limit = 10, apiUrl }, { dispatch: dispatch2, rejectWithValue }) => {
+    try {
+      const url = apiUrl || "https://api.forboc.ai";
+      const data = await dispatch2(sdkApi.endpoints.getGhostHistory.initiate({ limit, apiUrl: url })).unwrap();
+      return (data.sessions || []).map((s) => ({
+        sessionId: s.sessionId,
+        testSuite: s.testSuite,
+        startedAt: s.startedAt,
+        completedAt: s.completedAt,
+        status: s.status,
+        passRate: s.passRate
+      }));
+    } catch (e) {
+      return rejectWithValue(e.message || "Failed to get ghost history");
+    }
+  }
+);
+var ghostSlice = (0, import_toolkit3.createSlice)({
+  name: "ghost",
+  initialState: initialState3,
+  reducers: {
+    clearGhostSession: (state) => {
+      state.activeSessionId = null;
+      state.status = null;
+      state.progress = 0;
+      state.results = null;
+    }
+  },
+  extraReducers: (builder) => {
+    builder.addCase(startGhostThunk.pending, (state) => {
+      state.loading = true;
+      state.error = null;
+    }).addCase(startGhostThunk.fulfilled, (state, action) => {
+      state.loading = false;
+      state.activeSessionId = action.payload.sessionId;
+      state.status = "running";
+      state.progress = 0;
+    }).addCase(startGhostThunk.rejected, (state, action) => {
+      state.loading = false;
+      state.error = action.payload;
+    }).addCase(getGhostStatusThunk.fulfilled, (state, action) => {
+      state.status = action.payload.status;
+      state.progress = action.payload.progress;
+    }).addCase(getGhostResultsThunk.fulfilled, (state, action) => {
+      state.results = action.payload;
+      state.status = "completed";
+    }).addCase(stopGhostThunk.fulfilled, (state) => {
+      state.status = "failed";
+    }).addCase(getGhostHistoryThunk.fulfilled, (state, action) => {
+      state.history = action.payload;
+    });
+  }
+});
+var { clearGhostSession } = ghostSlice.actions;
+var ghostSlice_default = ghostSlice.reducer;
 
 // src/utils.ts
+var SDK_VERSION = "0.5.9";
+var generateNPCId = () => `ag_${Date.now().toString(36)}`;
 var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 var pipe = (...fns) => (initialValue) => fns.reduce((acc, fn) => fn(acc), initialValue);
 var memoiseAsync = (fn) => {
@@ -350,161 +635,6 @@ var memoise = (fn) => {
   };
 };
 
-// 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 {
-    sessionId: data.sessionId,
-    status: data.runStatus
-  };
-};
-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 {
-    sessionId: data.ghostSessionId,
-    status: data.ghostStatus,
-    progress: data.ghostProgress,
-    startedAt: data.ghostStartedAt,
-    duration: data.ghostDuration,
-    errors: data.ghostErrors
-  };
-};
-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 {
-    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 || [])
-  };
-};
-var pollForCompletion = async (sessionId, pollIntervalMs, timeoutMs, startTime, apiUrl, onProgress) => {
-  if (Date.now() - startTime > timeoutMs) {
-    throw new Error(`Ghost session timed out after ${timeoutMs}ms`);
-  }
-  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 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 || DEFAULT_API_URL;
-  try {
-    const response = await fetch(`${url}/ghost/${sessionId}/stop`, { method: "POST" });
-    return { stopped: response.ok };
-  } catch (e) {
-    return { stopped: true };
-  }
-};
-var getGhostHistory = async (limit = 10, apiUrl) => {
-  const url = apiUrl || DEFAULT_API_URL;
-  try {
-    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,
-      testSuite: s.testSuite,
-      startedAt: s.startedAt,
-      completedAt: s.completedAt,
-      status: s.status,
-      passRate: s.passRate
-    }));
-  } catch (e) {
-    return [];
-  }
-};
-var createGhost = (config) => {
-  let _sessionId = null;
-  const apiUrl = config.apiUrl || DEFAULT_API_URL;
-  const run = async () => {
-    const result = await startGhostSession(config);
-    _sessionId = result.sessionId;
-    return _sessionId;
-  };
-  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 = (pollIntervalMs, timeoutMs, onProgress) => waitForGhostCompletion(ensureSessionId(), pollIntervalMs, timeoutMs, apiUrl, onProgress);
-  return { run, status, results, stop, waitForCompletion };
-};
-
-// src/cortex-remote.ts
-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",
-    ready: true,
-    engine: "remote"
-  });
-  const complete = async (prompt, options) => {
-    const response = await fetch(`${apiUrl}/cortex/${cortexId}/complete`, {
-      method: "POST",
-      headers: authHeaders,
-      body: JSON.stringify({ prompt, ...options })
-    });
-    if (!response.ok) throw new Error(`Remote Cortex failed: ${response.statusText}`);
-    const data = await response.json();
-    return data.text;
-  };
-  const completeStream = async function* (prompt, options) {
-    const result = await complete(prompt, options);
-    yield result;
-  };
-  return { init, complete, completeStream };
-};
-
 // src/stream.ts
 var consumeStream = async (stream, onChunk, acc = "", delayMs = 0) => {
   const { value, done } = await stream.next();
@@ -529,41 +659,454 @@ var streamFromCortexWithDelay = async (cortex, prompt, onChunk, options) => {
   return consumeStream(cortex.completeStream(prompt, completionOptions), onChunk, "", delayMs);
 };
 
-// src/index.ts
-var SDK_VERSION = "0.5.7";
+// src/store.ts
+var import_toolkit8 = require("@reduxjs/toolkit");
+
+// src/npcSlice.ts
+var import_toolkit4 = require("@reduxjs/toolkit");
+var npcAdapter = (0, import_toolkit4.createEntityAdapter)();
+var npcSlice = (0, import_toolkit4.createSlice)({
+  name: "npc",
+  initialState: npcAdapter.getInitialState({
+    activeNpcId: ""
+  }),
+  reducers: {
+    setNPCInfo: (state, action) => {
+      const { id, persona, initialState: initialState5 } = action.payload;
+      npcAdapter.upsertOne(state, {
+        id,
+        persona,
+        state: initialState5 || {},
+        history: [],
+        isBlocked: false
+      });
+      state.activeNpcId = id;
+    },
+    setActiveNPC: (state, action) => {
+      state.activeNpcId = action.payload;
+    },
+    setNPCState: (state, action) => {
+      const { id, state: npcState } = action.payload;
+      npcAdapter.updateOne(state, { id, changes: { state: npcState } });
+    },
+    updateNPCState: (state, action) => {
+      const { id, delta } = action.payload;
+      const npc = state.entities[id];
+      if (npc) {
+        npc.state = { ...npc.state, ...delta };
+      }
+    },
+    addToHistory: (state, action) => {
+      const { id, role, content } = action.payload;
+      const npc = state.entities[id];
+      if (npc) {
+        npc.history.push({ role, content });
+      }
+    },
+    setHistory: (state, action) => {
+      const { id, history } = action.payload;
+      npcAdapter.updateOne(state, { id, changes: { history } });
+    },
+    setLastAction: (state, action) => {
+      const { id, action: npcAction } = action.payload;
+      npcAdapter.updateOne(state, { id, changes: { lastAction: npcAction } });
+    },
+    blockAction: (state, action) => {
+      const { id, reason } = action.payload;
+      npcAdapter.updateOne(state, { id, changes: { isBlocked: true, blockReason: reason } });
+    },
+    clearBlock: (state, action) => {
+      npcAdapter.updateOne(state, { id: action.payload, changes: { isBlocked: false, blockReason: void 0 } });
+    },
+    removeNPC: npcAdapter.removeOne
+  }
+});
+var {
+  setNPCInfo,
+  setActiveNPC,
+  setNPCState,
+  updateNPCState,
+  addToHistory,
+  setHistory,
+  setLastAction,
+  blockAction,
+  clearBlock,
+  removeNPC
+} = npcSlice.actions;
+var {
+  selectById: selectNPCById,
+  selectIds: selectNPCIds,
+  selectEntities: selectNPCEntities,
+  selectAll: selectAllNPCs,
+  selectTotal: selectTotalNPCs
+} = npcAdapter.getSelectors((state) => state.npc);
+var selectActiveNpcId = (state) => state.npc.activeNpcId;
+var selectActiveNPC = (state) => {
+  const id = selectActiveNpcId(state);
+  return state.npc.entities[id];
+};
+var npcSlice_default = npcSlice.reducer;
+
+// src/cortexSlice.ts
+var import_toolkit5 = require("@reduxjs/toolkit");
+var initialState4 = {
+  status: {
+    id: "init",
+    model: "none",
+    ready: false,
+    engine: "mock"
+  },
+  isInitializing: false
+};
+var initRemoteCortexThunk = (0, import_toolkit5.createAsyncThunk)(
+  "cortex/initRemote",
+  async ({ model = "api-integrated" }) => {
+    return {
+      id: `remote_${Date.now()}`,
+      model,
+      ready: true,
+      engine: "remote"
+    };
+  }
+);
+var completeRemoteThunk = (0, import_toolkit5.createAsyncThunk)(
+  "cortex/completeRemote",
+  async ({ cortexId, prompt, options, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
+    try {
+      const data = await dispatch2(sdkApi.endpoints.postCortexComplete.initiate({
+        cortexId,
+        prompt,
+        options,
+        apiUrl,
+        apiKey
+      })).unwrap();
+      return data.text;
+    } catch (e) {
+      return rejectWithValue(e.message || "Remote completing failed");
+    }
+  }
+);
+var cortexSlice = (0, import_toolkit5.createSlice)({
+  name: "cortex",
+  initialState: initialState4,
+  reducers: {
+    cortexInitStart: (state) => {
+      state.isInitializing = true;
+      state.error = void 0;
+    },
+    cortexInitSuccess: (state, action) => {
+      state.status = action.payload;
+      state.isInitializing = false;
+      state.error = void 0;
+    },
+    cortexInitFailed: (state, action) => {
+      state.isInitializing = false;
+      state.error = action.payload;
+    },
+    setCortexStatus: (state, action) => {
+      state.status = action.payload;
+    }
+  },
+  extraReducers: (builder) => {
+    builder.addCase(initRemoteCortexThunk.fulfilled, (state, action) => {
+      state.status = action.payload;
+      state.isInitializing = false;
+    }).addCase(completeRemoteThunk.rejected, (state, action) => {
+      state.error = action.payload;
+    });
+  }
+});
+var {
+  cortexInitStart,
+  cortexInitSuccess,
+  cortexInitFailed,
+  setCortexStatus
+} = cortexSlice.actions;
+var cortexSlice_default = cortexSlice.reducer;
+
+// src/memorySlice.ts
+var import_toolkit6 = require("@reduxjs/toolkit");
+var memoryAdapter = (0, import_toolkit6.createEntityAdapter)();
+var memorySlice = (0, import_toolkit6.createSlice)({
+  name: "memory",
+  initialState: memoryAdapter.getInitialState({
+    storageStatus: "idle",
+    recallStatus: "idle",
+    error: null,
+    lastRecalledIds: []
+  }),
+  reducers: {
+    memoryStoreStart: (state) => {
+      state.storageStatus = "storing";
+      state.error = null;
+    },
+    memoryStoreSuccess: (state, action) => {
+      state.storageStatus = "idle";
+      memoryAdapter.upsertOne(state, action.payload);
+    },
+    memoryStoreFailed: (state, action) => {
+      state.storageStatus = "error";
+      state.error = action.payload;
+    },
+    memoryRecallStart: (state) => {
+      state.recallStatus = "recalling";
+      state.error = null;
+    },
+    memoryRecallSuccess: (state, action) => {
+      state.recallStatus = "idle";
+      memoryAdapter.upsertMany(state, action.payload);
+      state.lastRecalledIds = action.payload.map((m) => memoryAdapter.selectId(m));
+    },
+    memoryRecallFailed: (state, action) => {
+      state.recallStatus = "error";
+      state.error = action.payload;
+    },
+    memoryClear: (state) => {
+      memoryAdapter.removeAll(state);
+      state.lastRecalledIds = [];
+    }
+  }
+});
+var {
+  memoryStoreStart,
+  memoryStoreSuccess,
+  memoryStoreFailed,
+  memoryRecallStart,
+  memoryRecallSuccess,
+  memoryRecallFailed,
+  memoryClear
+} = memorySlice.actions;
+var {
+  selectById: selectMemoryById,
+  selectAll: selectAllMemories
+} = memoryAdapter.getSelectors((state) => state.memory);
+var selectLastRecalledMemories = (state) => {
+  return state.memory.lastRecalledIds.map((id) => state.memory.entities[id]).filter(Boolean);
+};
+var memorySlice_default = memorySlice.reducer;
+
+// src/listeners.ts
+var import_toolkit7 = require("@reduxjs/toolkit");
+var sdkListenerMiddleware = (0, import_toolkit7.createListenerMiddleware)();
+var startAppListening = sdkListenerMiddleware.startListening.withTypes();
+startAppListening({
+  actionCreator: removeNPC,
+  effect: async (action, listenerApi) => {
+    const state = listenerApi.getState();
+    if (action.payload === state.npc.activeNpcId) {
+      listenerApi.dispatch(memoryClear());
+    }
+  }
+});
+
+// src/store.ts
+var createSDKStore = (extraReducers = {}) => {
+  return (0, import_toolkit8.configureStore)({
+    reducer: {
+      [sdkApi.reducerPath]: sdkApi.reducer,
+      npc: npcSlice_default,
+      cortex: cortexSlice_default,
+      memory: memorySlice_default,
+      ghost: ghostSlice_default,
+      soul: soulSlice_default,
+      bridge: bridgeSlice_default,
+      ...extraReducers
+    },
+    middleware: (getDefaultMiddleware) => getDefaultMiddleware({
+      serializableCheck: false
+      // Allow non-serializable for engine refs in specific slices if needed, though we try to keep them external
+    }).prepend(sdkListenerMiddleware.middleware).concat(sdkApi.middleware)
+  });
+};
+var store = createSDKStore();
+var dispatch = store.dispatch;
+
+// src/thunks.ts
+var import_toolkit9 = require("@reduxjs/toolkit");
+var processNPC = (0, import_toolkit9.createAsyncThunk)(
+  "npc/process",
+  async ({ npcId: argNpcId, text, context = {}, apiUrl, apiKey, memory, cortex, persona: argPersona }, { getState, dispatch: dispatch2 }) => {
+    const stateNpcId = selectActiveNpcId(getState());
+    const activeNpc = selectActiveNPC(getState());
+    const npcId = argNpcId || stateNpcId;
+    const persona = argPersona || activeNpc?.persona;
+    const currentState = activeNpc?.state || {};
+    if (argNpcId && argNpcId !== stateNpcId) {
+      dispatch2(setNPCInfo({ id: argNpcId, persona: persona || "Default" }));
+    }
+    const directiveResult = await dispatch2(
+      sdkApi.endpoints.postDirective.initiate({ npcId, request: { observation: text, npcState: currentState, context }, apiUrl, apiKey })
+    ).unwrap();
+    const recalledMemories = memory && directiveResult.memoryRecall ? await memory.recall(
+      directiveResult.memoryRecall.query,
+      directiveResult.memoryRecall.limit,
+      directiveResult.memoryRecall.threshold
+    ).then((mems) => mems.map((m) => ({ text: m.text, type: m.type, importance: m.importance }))).catch(() => []) : [];
+    const contextResult = await dispatch2(
+      sdkApi.endpoints.postContext.initiate({ npcId, request: { memories: recalledMemories, observation: text, npcState: currentState, persona: persona || "Default" }, apiUrl, apiKey })
+    ).unwrap();
+    let generatedText = "";
+    if (cortex) {
+      generatedText = await cortex.complete(contextResult.prompt, {
+        maxTokens: contextResult.constraints.maxTokens,
+        temperature: contextResult.constraints.temperature,
+        stop: contextResult.constraints.stop
+      });
+    } else {
+      const remoteResult = await dispatch2(sdkApi.endpoints.postCortexComplete.initiate({
+        cortexId: "remote",
+        // Or generic
+        prompt: contextResult.prompt,
+        options: contextResult.constraints,
+        apiUrl,
+        apiKey
+      })).unwrap();
+      generatedText = remoteResult.text || "";
+    }
+    const verdictResult = await dispatch2(
+      sdkApi.endpoints.postVerdict.initiate({ npcId, request: { generatedOutput: generatedText, observation: text, npcState: currentState }, apiUrl, apiKey })
+    ).unwrap();
+    if (!verdictResult.valid) {
+      dispatch2(blockAction({ id: npcId, reason: "Validation Failed" }));
+      return { dialogue: "... [Blocked]", action: { type: "BLOCKED", reason: "Validation Failed" } };
+    }
+    if (memory && verdictResult.memoryStore) {
+      for (const inst of verdictResult.memoryStore) {
+        await memory.store(inst.text, inst.type, inst.importance).catch((e) => console.warn("Memory store failed:", e));
+      }
+    }
+    if (verdictResult.stateDelta) {
+      dispatch2(updateNPCState({ id: npcId, delta: verdictResult.stateDelta }));
+    }
+    const action = verdictResult.action ? { ...verdictResult.action, signature: verdictResult.signature } : void 0;
+    dispatch2(setLastAction({ id: npcId, action }));
+    dispatch2(addToHistory({ id: npcId, role: "user", content: text }));
+    dispatch2(addToHistory({ id: npcId, role: "assistant", content: verdictResult.dialogue }));
+    return {
+      dialogue: verdictResult.dialogue,
+      action,
+      thought: verdictResult.dialogue
+    };
+  }
+);
+var speakNPC = (0, import_toolkit9.createAsyncThunk)(
+  "npc/speak",
+  async ({ npcId: argNpcId, text, context = {}, apiUrl, apiKey }, { getState, dispatch: dispatch2 }) => {
+    const stateNpcId = selectActiveNpcId(getState());
+    const activeNpc = selectActiveNPC(getState());
+    const npcId = argNpcId || stateNpcId;
+    const currentState = activeNpc?.state || {};
+    const data = await dispatch2(sdkApi.endpoints.postSpeak.initiate({
+      npcId,
+      request: { speakMessage: text, speakContext: context, speakNPCState: currentState },
+      apiUrl,
+      apiKey
+    })).unwrap();
+    if (data.speakHistory) {
+      dispatch2(setHistory({ id: npcId, history: data.speakHistory }));
+    }
+    return data.speakReply;
+  }
+);
+var dialogueNPC = (0, import_toolkit9.createAsyncThunk)(
+  "npc/dialogue",
+  async ({ npcId: argNpcId, text, context = [], apiUrl, apiKey }, { getState, dispatch: dispatch2 }) => {
+    const stateNpcId = selectActiveNpcId(getState());
+    const npcId = argNpcId || stateNpcId;
+    const data = await dispatch2(sdkApi.endpoints.postDialogue.initiate({
+      npcId,
+      request: { diagMessage: text, diagContext: context },
+      apiUrl,
+      apiKey
+    })).unwrap();
+    return data.diagReply;
+  }
+);
+var localExportSoulThunk = (0, import_toolkit9.createAsyncThunk)(
+  "npc/localExportSoul",
+  async ({ id, memory }, { getState }) => {
+    const state = getState().npc;
+    const npcId = id || state.activeNpcId;
+    const npc = state.entities[npcId];
+    if (!npc) throw new Error(`NPC ${npcId} not found`);
+    const memories = memory ? await memory.export().catch(() => []) : [];
+    return exportToSoul(npcId, "NPC", npc.persona, npc.state, memories);
+  }
+);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   SDK_VERSION,
-  createAgent,
-  createBridge,
-  createGhost,
+  addToHistory,
+  blockAction,
+  bridgeSlice,
+  clearBlock,
+  clearBridgeValidation,
+  clearGhostSession,
+  clearSoulState,
+  completeRemoteThunk,
+  cortexInitFailed,
+  cortexInitStart,
+  cortexInitSuccess,
+  cortexSlice,
   createInitialState,
-  createRemoteCortex,
-  createSoul,
-  createSoulInstance,
+  createSDKStore,
   delay,
-  deserializeSoul,
-  exportSoul,
+  dialogueNPC,
+  dispatch,
   exportToSoul,
-  fromSoul,
-  getGhostHistory,
-  getGhostResults,
-  getGhostStatus,
-  getSoulList,
-  importSoulFromArweave,
-  loadPreset,
+  generateNPCId,
+  getBridgeRulesThunk,
+  getGhostHistoryThunk,
+  getGhostResultsThunk,
+  getGhostStatusThunk,
+  getSoulListThunk,
+  ghostSlice,
+  importSoulFromArweaveThunk,
+  initRemoteCortexThunk,
+  loadBridgePresetThunk,
+  localExportSoulThunk,
   memoise,
   memoiseAsync,
+  memoryClear,
+  memoryRecallFailed,
+  memoryRecallStart,
+  memoryRecallSuccess,
+  memorySlice,
+  memoryStoreFailed,
+  memoryStoreStart,
+  memoryStoreSuccess,
+  npcSlice,
   pipe,
-  serializeSoul,
-  startGhostSession,
-  stopGhostSession,
+  processNPC,
+  remoteExportSoulThunk,
+  removeNPC,
+  sdkApi,
+  selectActiveNPC,
+  selectActiveNpcId,
+  selectAllMemories,
+  selectAllNPCs,
+  selectLastRecalledMemories,
+  selectMemoryById,
+  selectNPCById,
+  selectNPCEntities,
+  selectNPCIds,
+  selectTotalNPCs,
+  setActiveNPC,
+  setCortexStatus,
+  setHistory,
+  setLastAction,
+  setNPCInfo,
+  setNPCState,
+  soulSlice,
+  speakNPC,
+  startGhostThunk,
+  stopGhostThunk,
+  store,
   streamFromCortex,
   streamFromCortexWithDelay,
   streamToCallback,
   streamToString,
-  updateAgentState,
-  validateAction,
-  validateSoul,
-  waitForGhostCompletion
+  updateNPCState,
+  updateNPCStateLocally,
+  validateBridgeThunk
 });