@forbocai/core 0.5.9 → 0.6.1

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,312 +17,864 @@ 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,
+  checkApiStatusThunk: () => checkApiStatusThunk,
+  clearBlock: () => clearBlock,
+  clearBridgeValidation: () => clearBridgeValidation,
+  clearDirectivesForNpc: () => clearDirectivesForNpc,
+  clearGhostSession: () => clearGhostSession,
+  clearMemoryRemoteThunk: () => clearMemoryRemoteThunk,
+  clearSoulState: () => clearSoulState,
+  completeRemoteThunk: () => completeRemoteThunk,
+  contextComposed: () => contextComposed,
+  cortexInitFailed: () => cortexInitFailed,
+  cortexInitStart: () => cortexInitStart,
+  cortexInitSuccess: () => cortexInitSuccess,
+  cortexSlice: () => cortexSlice,
   createInitialState: () => createInitialState,
-  createRemoteCortex: () => createRemoteCortex,
-  createSoul: () => createSoul,
-  createSoulInstance: () => createSoulInstance,
+  createSDKStore: () => createSDKStore,
   delay: () => delay,
-  deserializeSoul: () => deserializeSoul,
-  exportSoul: () => exportSoul,
+  deleteRulesetThunk: () => deleteRulesetThunk,
+  directiveReceived: () => directiveReceived,
+  directiveRunFailed: () => directiveRunFailed,
+  directiveRunStarted: () => directiveRunStarted,
+  directiveSlice: () => directiveSlice,
+  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,
+  importNpcFromSoulThunk: () => importNpcFromSoulThunk,
+  importSoulFromArweaveThunk: () => importSoulFromArweaveThunk,
+  initRemoteCortexThunk: () => initRemoteCortexThunk,
+  listCortexModelsThunk: () => listCortexModelsThunk,
+  listMemoryRemoteThunk: () => listMemoryRemoteThunk,
+  listRulePresetsThunk: () => listRulePresetsThunk,
+  listRulesetsThunk: () => listRulesetsThunk,
+  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,
+  recallMemoryRemoteThunk: () => recallMemoryRemoteThunk,
+  registerRulesetThunk: () => registerRulesetThunk,
+  remoteExportSoulThunk: () => remoteExportSoulThunk,
+  removeNPC: () => removeNPC,
+  sdkApi: () => sdkApi,
+  selectActiveDirective: () => selectActiveDirective,
+  selectActiveDirectiveId: () => selectActiveDirectiveId,
+  selectActiveNPC: () => selectActiveNPC,
+  selectActiveNpcId: () => selectActiveNpcId,
+  selectAllDirectives: () => selectAllDirectives,
+  selectAllMemories: () => selectAllMemories,
+  selectAllNPCs: () => selectAllNPCs,
+  selectDirectiveById: () => selectDirectiveById,
+  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,
+  startGhostThunk: () => startGhostThunk,
+  stopGhostThunk: () => stopGhostThunk,
+  store: () => store,
+  storeMemoryRemoteThunk: () => storeMemoryRemoteThunk,
   streamFromCortex: () => streamFromCortex,
   streamFromCortexWithDelay: () => streamFromCortexWithDelay,
   streamToCallback: () => streamToCallback,
   streamToString: () => streamToString,
-  updateAgentState: () => updateAgentState,
-  validateAction: () => validateAction,
-  validateSoul: () => validateSoul,
-  waitForGhostCompletion: () => waitForGhostCompletion
+  updateNPCState: () => updateNPCState,
+  updateNPCStateLocally: () => updateNPCStateLocally,
+  validateBridgeThunk: () => validateBridgeThunk,
+  verdictValidated: () => verdictValidated,
+  verifySoulThunk: () => verifySoulThunk
 });
 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", "Rule"],
+  endpoints: (builder) => ({
+    // Cortex Endpoints
+    getCortexModels: builder.query({
+      query: ({ apiUrl, apiKey }) => ({
+        url: `${apiUrl}/cortex/models`,
+        method: "GET",
+        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
+      }),
+      providesTags: ["Cortex"],
+      transformResponse: (response) => response || []
+    }),
+    postCortexInit: builder.mutation({
+      query: ({ request, apiUrl, apiKey }) => ({
+        url: `${apiUrl}/cortex/init`,
+        method: "POST",
+        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
+        body: request
+      }),
+      invalidatesTags: ["Cortex"],
+      transformResponse: (response) => response
+    }),
+    // 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
+        };
+      }
+    }),
+    postMemoryStore: builder.mutation({
+      query: ({ npcId, request, apiUrl, apiKey }) => ({
+        url: `${apiUrl}/npcs/${npcId}/memory`,
+        method: "POST",
+        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
+        body: request
+      }),
+      invalidatesTags: (result, error, { npcId }) => [{ type: "Memory", id: npcId }],
+      transformResponse: (response) => response
+    }),
+    getMemoryList: builder.query({
+      query: ({ npcId, apiUrl, apiKey }) => ({
+        url: `${apiUrl}/npcs/${npcId}/memory`,
+        method: "GET",
+        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
+      }),
+      providesTags: (result, error, { npcId }) => [{ type: "Memory", id: npcId }],
+      transformResponse: (response) => response || []
+    }),
+    postMemoryRecall: builder.mutation({
+      query: ({ npcId, request, apiUrl, apiKey }) => ({
+        url: `${apiUrl}/npcs/${npcId}/memory/recall`,
+        method: "POST",
+        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
+        body: request
+      }),
+      invalidatesTags: (result, error, { npcId }) => [{ type: "Memory", id: npcId }],
+      transformResponse: (response) => response || []
+    }),
+    deleteMemoryClear: builder.mutation({
+      query: ({ npcId, apiUrl, apiKey }) => ({
+        url: `${apiUrl}/npcs/${npcId}/memory/clear`,
+        method: "DELETE",
+        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
+      }),
+      invalidatesTags: (result, error, { npcId }) => [{ type: "Memory", id: npcId }],
+      transformResponse: (response) => response
+    }),
+    // Ghost Endpoints
+    postGhostRun: builder.mutation({
+      query: ({ request, apiUrl, apiKey }) => ({
+        url: `${apiUrl}/ghost/run`,
+        method: "POST",
+        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
+        body: request
+      }),
+      invalidatesTags: ["Ghost"],
+      transformResponse: (response) => response
+    }),
+    getGhostStatus: builder.query({
+      query: ({ sessionId, apiUrl, apiKey }) => ({
+        url: `${apiUrl}/ghost/${sessionId}/status`,
+        method: "GET",
+        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
+      }),
+      providesTags: (result, error, { sessionId }) => [{ type: "Ghost", id: sessionId }],
+      transformResponse: (response) => response
+    }),
+    getGhostResults: builder.query({
+      query: ({ sessionId, apiUrl, apiKey }) => ({
+        url: `${apiUrl}/ghost/${sessionId}/results`,
+        method: "GET",
+        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
+      }),
+      providesTags: (result, error, { sessionId }) => [{ type: "Ghost", id: sessionId }],
+      transformResponse: (response) => response
+    }),
+    postGhostStop: builder.mutation({
+      query: ({ sessionId, apiUrl, apiKey }) => ({
+        url: `${apiUrl}/ghost/${sessionId}/stop`,
+        method: "POST",
+        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
+      }),
+      invalidatesTags: (result, error, { sessionId }) => [{ type: "Ghost", id: sessionId }],
+      transformResponse: (response) => ({
+        stopped: response?.stopStatus === "stopped",
+        stopStatus: response?.stopStatus,
+        stopSessionId: response?.stopSessionId
+      })
+    }),
+    getGhostHistory: builder.query({
+      query: ({ limit, apiUrl, apiKey }) => ({
+        url: `${apiUrl}/ghost/history?limit=${limit}`,
+        method: "GET",
+        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
+      }),
+      providesTags: ["Ghost"],
+      transformResponse: (response) => response
+    }),
+    // Soul Endpoints
+    postSoulExport: builder.mutation({
+      query: ({ npcId, request, apiUrl, apiKey }) => ({
+        url: `${apiUrl}/npcs/${npcId}/soul/export`,
+        method: "POST",
+        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
+        body: request
+      }),
+      invalidatesTags: ["Soul"],
+      transformResponse: (response) => response
+    }),
+    getSoulImport: builder.query({
+      query: ({ txId, apiUrl, apiKey }) => ({
+        url: `${apiUrl}/souls/${txId}`,
+        method: "GET",
+        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
+      }),
+      providesTags: (result, error, { txId }) => [{ type: "Soul", id: txId }],
+      transformResponse: (response) => response
+    }),
+    getSouls: builder.query({
+      query: ({ limit, apiUrl, apiKey }) => ({
+        url: `${apiUrl}/souls?limit=${limit}`,
+        method: "GET",
+        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
+      }),
+      providesTags: ["Soul"],
+      transformResponse: (response) => response
+    }),
+    // Bridge Endpoints
+    postBridgeValidate: builder.mutation({
+      query: ({ request, npcId, apiUrl, apiKey }) => ({
+        url: npcId ? `${apiUrl}/bridge/validate/${npcId}` : `${apiUrl}/bridge/validate`,
+        method: "POST",
+        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
+        body: request
+      }),
+      invalidatesTags: ["Bridge"],
+      transformResponse: (response) => response.brResult || response
+    }),
+    getBridgeRules: builder.query({
+      query: ({ apiUrl, apiKey }) => ({
+        url: `${apiUrl}/bridge/rules`,
+        method: "GET",
+        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
+      }),
+      providesTags: ["Bridge"],
+      transformResponse: (response) => response
+    }),
+    postBridgePreset: builder.mutation({
+      query: ({ presetName, apiUrl, apiKey }) => ({
+        url: `${apiUrl}/rules/presets/${presetName}`,
+        method: "POST",
+        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
+      }),
+      invalidatesTags: ["Bridge"],
+      transformResponse: (response) => response
+    }),
+    // Rules Endpoints
+    getRulesets: builder.query({
+      query: ({ apiUrl, apiKey }) => ({
+        url: `${apiUrl}/rules`,
+        method: "GET",
+        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
+      }),
+      providesTags: ["Rule"],
+      transformResponse: (response) => response || []
+    }),
+    getRulePresets: builder.query({
+      query: ({ apiUrl, apiKey }) => ({
+        url: `${apiUrl}/rules/presets`,
+        method: "GET",
+        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
+      }),
+      providesTags: ["Rule"],
+      transformResponse: (response) => response || []
+    }),
+    postRuleRegister: builder.mutation({
+      query: ({ request, apiUrl, apiKey }) => ({
+        url: `${apiUrl}/rules`,
+        method: "POST",
+        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
+        body: request
+      }),
+      invalidatesTags: ["Rule"],
+      transformResponse: (response) => response
+    }),
+    deleteRule: builder.mutation({
+      query: ({ rulesetId, apiUrl, apiKey }) => ({
+        url: `${apiUrl}/rules/${rulesetId}`,
+        method: "DELETE",
+        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
+      }),
+      invalidatesTags: ["Rule"],
+      transformResponse: (_response) => ({ deleted: true })
+    }),
+    // Additional Soul/NPC Endpoints
+    postSoulVerify: builder.mutation({
+      query: ({ txId, apiUrl, apiKey }) => ({
+        url: `${apiUrl}/souls/${txId}/verify`,
+        method: "POST",
+        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
+      }),
+      invalidatesTags: ["Soul"],
+      transformResponse: (response) => ({
+        valid: response.verifyValid ?? response.valid ?? false,
+        reason: response.verifyReason ?? response.reason
+      })
+    }),
+    postNpcImport: builder.mutation({
+      query: ({ request, apiUrl, apiKey }) => ({
+        url: `${apiUrl}/npcs/import`,
+        method: "POST",
+        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
+        body: request
+      }),
+      invalidatesTags: ["NPC"],
+      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: [],
+  availableRulesets: [],
+  availablePresetIds: [],
+  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" } };
-    }
-    if (config.memory && verdictData.memoryStore) {
-      storeMemoriesRecursive(config.memory, verdictData.memoryStore);
-    }
-    if (verdictData.stateDelta) {
-      setState(updateAgentState(_state, verdictData.stateDelta));
-    }
-    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 validateBridgeThunk = (0, import_toolkit.createAsyncThunk)(
+  "bridge/validate",
+  async ({ action, context, npcId, apiUrl, apiKey }, { 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,
+        apiKey
+      })).unwrap();
+      return data;
+    } catch (e) {
+      return rejectWithValue(e.message || "Bridge validation failed");
+    }
+  }
+);
+var loadBridgePresetThunk = (0, import_toolkit.createAsyncThunk)(
+  "bridge/loadPreset",
+  async ({ presetName, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
+    try {
+      const url = apiUrl || "https://api.forboc.ai";
+      return await dispatch2(sdkApi.endpoints.postBridgePreset.initiate({ presetName, apiUrl: url, apiKey })).unwrap();
+    } catch (e) {
+      return rejectWithValue(e.message || "Failed to load preset");
+    }
+  }
+);
+var getBridgeRulesThunk = (0, import_toolkit.createAsyncThunk)(
+  "bridge/rules",
+  async ({ apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
+    try {
+      const url = apiUrl || "https://api.forboc.ai";
+      return await dispatch2(sdkApi.endpoints.getBridgeRules.initiate({ apiUrl: url, apiKey })).unwrap();
+    } catch (e) {
+      return rejectWithValue(e.message || "Failed to list bridge rules");
+    }
+  }
+);
+var listRulesetsThunk = (0, import_toolkit.createAsyncThunk)(
+  "bridge/listRulesets",
+  async ({ apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
+    try {
+      const url = apiUrl || "https://api.forboc.ai";
+      return await dispatch2(sdkApi.endpoints.getRulesets.initiate({ apiUrl: url, apiKey })).unwrap();
+    } catch (e) {
+      return rejectWithValue(e.message || "Failed to list rulesets");
+    }
+  }
+);
+var listRulePresetsThunk = (0, import_toolkit.createAsyncThunk)(
+  "bridge/listRulePresets",
+  async ({ apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
+    try {
+      const url = apiUrl || "https://api.forboc.ai";
+      return await dispatch2(sdkApi.endpoints.getRulePresets.initiate({ apiUrl: url, apiKey })).unwrap();
+    } catch (e) {
+      return rejectWithValue(e.message || "Failed to list rule presets");
+    }
+  }
+);
+var registerRulesetThunk = (0, import_toolkit.createAsyncThunk)(
+  "bridge/registerRuleset",
+  async ({ ruleset, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
+    try {
+      const url = apiUrl || "https://api.forboc.ai";
+      return await dispatch2(sdkApi.endpoints.postRuleRegister.initiate({ request: ruleset, apiUrl: url, apiKey })).unwrap();
+    } catch (e) {
+      return rejectWithValue(e.message || "Failed to register ruleset");
+    }
+  }
+);
+var deleteRulesetThunk = (0, import_toolkit.createAsyncThunk)(
+  "bridge/deleteRuleset",
+  async ({ rulesetId, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
+    try {
+      const url = apiUrl || "https://api.forboc.ai";
+      return await dispatch2(sdkApi.endpoints.deleteRule.initiate({ rulesetId, apiUrl: url, apiKey })).unwrap();
+    } catch (e) {
+      return rejectWithValue(e.message || "Failed to delete ruleset");
+    }
+  }
+);
+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) => {
+    }).addCase(listRulesetsThunk.fulfilled, (state, action) => {
+      state.availableRulesets = action.payload;
+    }).addCase(listRulePresetsThunk.fulfilled, (state, action) => {
+      state.availablePresetIds = action.payload;
     });
-    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, apiKey, 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,
+        apiKey
+      })).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, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
+    try {
+      const url = apiUrl || "https://api.forboc.ai";
+      const data = await dispatch2(sdkApi.endpoints.getSoulImport.initiate({ txId, apiUrl: url, apiKey })).unwrap();
+      return data;
+    } catch (e) {
+      return rejectWithValue(e.message || "Soul import failed");
+    }
+  }
+);
+var getSoulListThunk = (0, import_toolkit2.createAsyncThunk)(
+  "soul/list",
+  async ({ limit = 50, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
+    try {
+      const url = apiUrl || "https://api.forboc.ai";
+      const data = await dispatch2(sdkApi.endpoints.getSouls.initiate({ limit, apiUrl: url, apiKey })).unwrap();
+      return data.souls || [];
+    } catch (e) {
+      return rejectWithValue(e.message || "Failed to list souls");
+    }
+  }
+);
+var verifySoulThunk = (0, import_toolkit2.createAsyncThunk)(
+  "soul/verify",
+  async ({ txId, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
+    try {
+      const url = apiUrl || "https://api.forboc.ai";
+      return await dispatch2(sdkApi.endpoints.postSoulVerify.initiate({ txId, apiUrl: url, apiKey })).unwrap();
+    } catch (e) {
+      return rejectWithValue(e.message || "Soul verify failed");
+    }
+  }
+);
+var importNpcFromSoulThunk = (0, import_toolkit2.createAsyncThunk)(
+  "soul/importNpc",
+  async ({ txId, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
+    try {
+      const url = apiUrl || "https://api.forboc.ai";
+      return await dispatch2(sdkApi.endpoints.postNpcImport.initiate({
+        request: { txIdRef: txId },
+        apiUrl: url,
+        apiKey
+      })).unwrap();
+    } catch (e) {
+      return rejectWithValue(e.message || "NPC import from soul failed");
+    }
+  }
+);
+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,
+        apiKey: config.apiKey
+      })).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, apiKey }, { 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, apiKey })).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();
-};
+);
+var getGhostResultsThunk = (0, import_toolkit3.createAsyncThunk)(
+  "ghost/results",
+  async ({ sessionId, apiUrl, apiKey }, { 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, apiKey })).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, apiKey }, { 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.postGhostStop.initiate({ sessionId: targetSession, apiUrl: url, apiKey })).unwrap();
+      return {
+        stopped: data.stopped,
+        status: data.stopStatus,
+        sessionId: data.stopSessionId
+      };
+    } catch (e) {
+      return rejectWithValue(e.message || "Failed to stop ghost session");
+    }
+  }
+);
+var getGhostHistoryThunk = (0, import_toolkit3.createAsyncThunk)(
+  "ghost/history",
+  async ({ limit = 10, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
+    try {
+      const url = apiUrl || "https://api.forboc.ai";
+      const data = await dispatch2(sdkApi.endpoints.getGhostHistory.initiate({ limit, apiUrl: url, apiKey })).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, action) => {
+      if (action.payload.stopped) {
+        state.status = "failed";
+      } else {
+        state.error = action.payload.status || "Ghost stop request did not stop a session";
+      }
+    }).addCase(stopGhostThunk.rejected, (state, action) => {
+      state.error = action.payload;
+    }).addCase(getGhostHistoryThunk.fulfilled, (state, action) => {
+      state.history = action.payload;
+    });
+  }
+});
+var { clearGhostSession } = ghostSlice.actions;
+var ghostSlice_default = ghostSlice.reducer;
 
-// src/index.ts
-init_soul();
+// src/utils/sdkVersion.ts
+var SDK_VERSION = "0.6.0";
+
+// src/utils/generateNPCId.ts
+var generateNPCId = () => `ag_${Date.now().toString(36)}`;
 
-// src/utils.ts
+// src/utils/delay.ts
 var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+// src/utils/pipe.ts
 var pipe = (...fns) => (initialValue) => fns.reduce((acc, fn) => fn(acc), initialValue);
+
+// src/utils/memoiseAsync.ts
 var memoiseAsync = (fn) => {
   let cached = null;
   let promise = null;
@@ -339,6 +888,8 @@ var memoiseAsync = (fn) => {
     return promise;
   };
 };
+
+// src/utils/memoise.ts
 var memoise = (fn) => {
   let cached = null;
   let initialized = false;
@@ -350,161 +901,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 +925,642 @@ var streamFromCortexWithDelay = async (cortex, prompt, onChunk, options) => {
   return consumeStream(cortex.completeStream(prompt, completionOptions), onChunk, "", delayMs);
 };
 
-// src/index.ts
-var SDK_VERSION = "0.5.9";
+// src/store.ts
+var import_toolkit9 = 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", authKey, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
+    try {
+      const url = apiUrl || "https://api.forboc.ai";
+      const data = await dispatch2(sdkApi.endpoints.postCortexInit.initiate({
+        request: { requestedModel: model, authKey },
+        apiUrl: url,
+        apiKey
+      })).unwrap();
+      return {
+        id: data.cortexId,
+        model,
+        ready: data.state?.toLowerCase() === "ready",
+        engine: "remote"
+      };
+    } catch (e) {
+      return rejectWithValue(e.message || "Remote cortex init failed");
+    }
+  }
+);
+var listCortexModelsThunk = (0, import_toolkit5.createAsyncThunk)(
+  "cortex/listModels",
+  async ({ apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
+    try {
+      const url = apiUrl || "https://api.forboc.ai";
+      return await dispatch2(sdkApi.endpoints.getCortexModels.initiate({ apiUrl: url, apiKey })).unwrap();
+    } catch (e) {
+      return rejectWithValue(e.message || "Failed to list cortex models");
+    }
+  }
+);
+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/directiveSlice.ts
+var import_toolkit7 = require("@reduxjs/toolkit");
+var directiveAdapter = (0, import_toolkit7.createEntityAdapter)();
+var directiveSlice = (0, import_toolkit7.createSlice)({
+  name: "directive",
+  initialState: directiveAdapter.getInitialState({
+    activeDirectiveId: ""
+  }),
+  reducers: {
+    directiveRunStarted: (state, action) => {
+      const { id, npcId, observation } = action.payload;
+      directiveAdapter.upsertOne(state, {
+        id,
+        npcId,
+        observation,
+        status: "running",
+        startedAt: Date.now()
+      });
+      state.activeDirectiveId = id;
+    },
+    directiveReceived: (state, action) => {
+      const { id, response } = action.payload;
+      directiveAdapter.updateOne(state, {
+        id,
+        changes: { memoryRecall: response.memoryRecall }
+      });
+    },
+    contextComposed: (state, action) => {
+      const { id, prompt, constraints } = action.payload;
+      directiveAdapter.updateOne(state, {
+        id,
+        changes: { contextPrompt: prompt, contextConstraints: constraints }
+      });
+    },
+    verdictValidated: (state, action) => {
+      const { id, verdict } = action.payload;
+      directiveAdapter.updateOne(state, {
+        id,
+        changes: {
+          status: "completed",
+          completedAt: Date.now(),
+          verdictValid: verdict.valid,
+          verdictDialogue: verdict.dialogue,
+          verdictActionType: verdict.action?.type
+        }
+      });
+    },
+    directiveRunFailed: (state, action) => {
+      const { id, error } = action.payload;
+      directiveAdapter.updateOne(state, {
+        id,
+        changes: {
+          status: "failed",
+          completedAt: Date.now(),
+          error
+        }
+      });
+    },
+    clearDirectivesForNpc: (state, action) => {
+      const npcId = action.payload;
+      const idsToRemove = Object.values(state.entities).filter((item) => Boolean(item)).filter((item) => item.npcId === npcId).map((item) => item.id);
+      directiveAdapter.removeMany(state, idsToRemove);
+      if (idsToRemove.includes(state.activeDirectiveId)) {
+        state.activeDirectiveId = "";
+      }
+    }
+  }
+});
+var {
+  directiveRunStarted,
+  directiveReceived,
+  contextComposed,
+  verdictValidated,
+  directiveRunFailed,
+  clearDirectivesForNpc
+} = directiveSlice.actions;
+var {
+  selectById: selectDirectiveById,
+  selectAll: selectAllDirectives
+} = directiveAdapter.getSelectors((state) => state.directive);
+var selectActiveDirectiveId = (state) => state.directive.activeDirectiveId;
+var selectActiveDirective = (state) => {
+  const id = selectActiveDirectiveId(state);
+  return state.directive.entities[id];
+};
+var directiveSlice_default = directiveSlice.reducer;
+
+// src/listeners.ts
+var import_toolkit8 = require("@reduxjs/toolkit");
+var sdkListenerMiddleware = (0, import_toolkit8.createListenerMiddleware)();
+var startAppListening = sdkListenerMiddleware.startListening.withTypes();
+startAppListening({
+  actionCreator: removeNPC,
+  effect: async (action, listenerApi) => {
+    const removedNpcId = action.payload;
+    const state = listenerApi.getState();
+    listenerApi.dispatch(clearDirectivesForNpc(removedNpcId));
+    listenerApi.dispatch(clearBridgeValidation());
+    listenerApi.dispatch(clearGhostSession());
+    listenerApi.dispatch(clearSoulState());
+    listenerApi.dispatch(clearBlock(removedNpcId));
+    if (removedNpcId === state.npc.activeNpcId) {
+      listenerApi.dispatch(memoryClear());
+    }
+  }
+});
+
+// src/store.ts
+var createSDKStore = (extraReducers = {}) => {
+  return (0, import_toolkit9.configureStore)({
+    reducer: {
+      [sdkApi.reducerPath]: sdkApi.reducer,
+      npc: npcSlice_default,
+      cortex: cortexSlice_default,
+      memory: memorySlice_default,
+      directive: directiveSlice_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_toolkit10 = require("@reduxjs/toolkit");
+var processNPC = (0, import_toolkit10.createAsyncThunk)(
+  "npc/process",
+  async ({ npcId: argNpcId, text, context = {}, apiUrl, apiKey, memory, cortex, persona: argPersona }, { getState, dispatch: dispatch2, rejectWithValue }) => {
+    const stateNpcId = selectActiveNpcId(getState());
+    const activeNpc = selectActiveNPC(getState());
+    const npcId = argNpcId || stateNpcId;
+    const persona = argPersona || activeNpc?.persona;
+    const currentState = activeNpc?.state || {};
+    if (!npcId) {
+      return rejectWithValue("No npcId provided and no active NPC selected");
+    }
+    if (!persona) {
+      return rejectWithValue("No persona provided and no active NPC persona available");
+    }
+    if (!cortex) {
+      return rejectWithValue("No local cortex provided. SDK remote cortex fallback is disabled.");
+    }
+    if (argNpcId && argNpcId !== stateNpcId) {
+      dispatch2(setNPCInfo({ id: argNpcId, persona }));
+    }
+    const directiveId = `${npcId}:${Date.now()}`;
+    dispatch2(directiveRunStarted({ id: directiveId, npcId, observation: text }));
+    try {
+      const directiveResult = await dispatch2(
+        sdkApi.endpoints.postDirective.initiate({ npcId, request: { observation: text, npcState: currentState, context }, apiUrl, apiKey })
+      ).unwrap();
+      dispatch2(directiveReceived({ id: directiveId, response: directiveResult }));
+      if (directiveResult.memoryRecall && !memory) {
+        return rejectWithValue("API requested memory recall, but no memory engine is configured");
+      }
+      const recalledMemories = memory && directiveResult.memoryRecall ? (await memory.recall(
+        directiveResult.memoryRecall.query,
+        directiveResult.memoryRecall.limit,
+        directiveResult.memoryRecall.threshold
+      )).map((m) => ({ text: m.text, type: m.type, importance: m.importance })) : [];
+      const contextResult = await dispatch2(
+        sdkApi.endpoints.postContext.initiate({ npcId, request: { memories: recalledMemories, observation: text, npcState: currentState, persona }, apiUrl, apiKey })
+      ).unwrap();
+      dispatch2(contextComposed({ id: directiveId, prompt: contextResult.prompt, constraints: contextResult.constraints }));
+      const generatedText = await cortex.complete(contextResult.prompt, {
+        maxTokens: contextResult.constraints.maxTokens,
+        temperature: contextResult.constraints.temperature,
+        stop: contextResult.constraints.stop
+      });
+      const verdictResult = await dispatch2(
+        sdkApi.endpoints.postVerdict.initiate({ npcId, request: { generatedOutput: generatedText, observation: text, npcState: currentState }, apiUrl, apiKey })
+      ).unwrap();
+      dispatch2(verdictValidated({ id: directiveId, verdict: verdictResult }));
+      if (!verdictResult.valid) {
+        dispatch2(blockAction({ id: npcId, reason: verdictResult.dialogue || "Validation Failed" }));
+        return {
+          dialogue: verdictResult.dialogue,
+          action: verdictResult.action,
+          thought: verdictResult.dialogue
+        };
+      }
+      if (verdictResult.memoryStore?.length && !memory) {
+        return rejectWithValue("API returned memoryStore instructions, but no memory engine is configured");
+      }
+      if (memory && verdictResult.memoryStore) {
+        for (const inst of verdictResult.memoryStore) {
+          await memory.store(inst.text, inst.type, inst.importance);
+        }
+      }
+      if (verdictResult.stateDelta) {
+        dispatch2(updateNPCState({ id: npcId, delta: verdictResult.stateDelta }));
+      }
+      const action = verdictResult.action;
+      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
+      };
+    } catch (e) {
+      const message = e?.message || e?.data?.message || "Protocol processing failed";
+      dispatch2(directiveRunFailed({ id: directiveId, error: String(message) }));
+      return rejectWithValue(String(message));
+    }
+  }
+);
+var localExportSoulThunk = (0, import_toolkit10.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() : [];
+    return exportToSoul(npcId, "NPC", npc.persona, npc.state, memories);
+  }
+);
+var checkApiStatusThunk = (0, import_toolkit10.createAsyncThunk)(
+  "system/checkApiStatus",
+  async ({ apiUrl }, { dispatch: dispatch2, rejectWithValue }) => {
+    try {
+      return await dispatch2(sdkApi.endpoints.getApiStatus.initiate({ apiUrl })).unwrap();
+    } catch (e) {
+      return rejectWithValue(e?.message || "Connection failed");
+    }
+  }
+);
+var listMemoryRemoteThunk = (0, import_toolkit10.createAsyncThunk)(
+  "memory/listRemote",
+  async ({ npcId, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
+    try {
+      const data = await dispatch2(sdkApi.endpoints.getMemoryList.initiate({ npcId, apiUrl, apiKey })).unwrap();
+      return data || [];
+    } catch (e) {
+      return rejectWithValue(e?.message || "Failed to list memories");
+    }
+  }
+);
+var recallMemoryRemoteThunk = (0, import_toolkit10.createAsyncThunk)(
+  "memory/recallRemote",
+  async ({ npcId, query, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
+    try {
+      const data = await dispatch2(
+        sdkApi.endpoints.postMemoryRecall.initiate({
+          npcId,
+          request: { query },
+          apiUrl,
+          apiKey
+        })
+      ).unwrap();
+      return data || [];
+    } catch (e) {
+      return rejectWithValue(e?.message || "Failed to recall memories");
+    }
+  }
+);
+var storeMemoryRemoteThunk = (0, import_toolkit10.createAsyncThunk)(
+  "memory/storeRemote",
+  async ({ npcId, observation, importance = 0.8, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
+    try {
+      return await dispatch2(
+        sdkApi.endpoints.postMemoryStore.initiate({
+          npcId,
+          request: { observation, importance },
+          apiUrl,
+          apiKey
+        })
+      ).unwrap();
+    } catch (e) {
+      return rejectWithValue(e?.message || "Failed to store memory");
+    }
+  }
+);
+var clearMemoryRemoteThunk = (0, import_toolkit10.createAsyncThunk)(
+  "memory/clearRemote",
+  async ({ npcId, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
+    try {
+      return await dispatch2(
+        sdkApi.endpoints.deleteMemoryClear.initiate({ npcId, apiUrl, apiKey })
+      ).unwrap();
+    } catch (e) {
+      return rejectWithValue(e?.message || "Failed to clear memories");
+    }
+  }
+);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   SDK_VERSION,
-  createAgent,
-  createBridge,
-  createGhost,
+  addToHistory,
+  blockAction,
+  bridgeSlice,
+  checkApiStatusThunk,
+  clearBlock,
+  clearBridgeValidation,
+  clearDirectivesForNpc,
+  clearGhostSession,
+  clearMemoryRemoteThunk,
+  clearSoulState,
+  completeRemoteThunk,
+  contextComposed,
+  cortexInitFailed,
+  cortexInitStart,
+  cortexInitSuccess,
+  cortexSlice,
   createInitialState,
-  createRemoteCortex,
-  createSoul,
-  createSoulInstance,
+  createSDKStore,
   delay,
-  deserializeSoul,
-  exportSoul,
+  deleteRulesetThunk,
+  directiveReceived,
+  directiveRunFailed,
+  directiveRunStarted,
+  directiveSlice,
+  dispatch,
   exportToSoul,
-  fromSoul,
-  getGhostHistory,
-  getGhostResults,
-  getGhostStatus,
-  getSoulList,
-  importSoulFromArweave,
-  loadPreset,
+  generateNPCId,
+  getBridgeRulesThunk,
+  getGhostHistoryThunk,
+  getGhostResultsThunk,
+  getGhostStatusThunk,
+  getSoulListThunk,
+  ghostSlice,
+  importNpcFromSoulThunk,
+  importSoulFromArweaveThunk,
+  initRemoteCortexThunk,
+  listCortexModelsThunk,
+  listMemoryRemoteThunk,
+  listRulePresetsThunk,
+  listRulesetsThunk,
+  loadBridgePresetThunk,
+  localExportSoulThunk,
   memoise,
   memoiseAsync,
+  memoryClear,
+  memoryRecallFailed,
+  memoryRecallStart,
+  memoryRecallSuccess,
+  memorySlice,
+  memoryStoreFailed,
+  memoryStoreStart,
+  memoryStoreSuccess,
+  npcSlice,
   pipe,
-  serializeSoul,
-  startGhostSession,
-  stopGhostSession,
+  processNPC,
+  recallMemoryRemoteThunk,
+  registerRulesetThunk,
+  remoteExportSoulThunk,
+  removeNPC,
+  sdkApi,
+  selectActiveDirective,
+  selectActiveDirectiveId,
+  selectActiveNPC,
+  selectActiveNpcId,
+  selectAllDirectives,
+  selectAllMemories,
+  selectAllNPCs,
+  selectDirectiveById,
+  selectLastRecalledMemories,
+  selectMemoryById,
+  selectNPCById,
+  selectNPCEntities,
+  selectNPCIds,
+  selectTotalNPCs,
+  setActiveNPC,
+  setCortexStatus,
+  setHistory,
+  setLastAction,
+  setNPCInfo,
+  setNPCState,
+  soulSlice,
+  startGhostThunk,
+  stopGhostThunk,
+  store,
+  storeMemoryRemoteThunk,
   streamFromCortex,
   streamFromCortexWithDelay,
   streamToCallback,
   streamToString,
-  updateAgentState,
-  validateAction,
-  validateSoul,
-  waitForGhostCompletion
+  updateNPCState,
+  updateNPCStateLocally,
+  validateBridgeThunk,
+  verdictValidated,
+  verifySoulThunk
 });