@forbocai/core 0.6.0 → 0.6.1

package/dist/index.js

@@ -24,11 +24,15 @@ __export(index_exports, {
   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,
@@ -36,7 +40,11 @@ __export(index_exports, {
   createInitialState: () => createInitialState,
   createSDKStore: () => createSDKStore,
   delay: () => delay,
-  dialogueNPC: () => dialogueNPC,
+  deleteRulesetThunk: () => deleteRulesetThunk,
+  directiveReceived: () => directiveReceived,
+  directiveRunFailed: () => directiveRunFailed,
+  directiveRunStarted: () => directiveRunStarted,
+  directiveSlice: () => directiveSlice,
   dispatch: () => dispatch,
   exportToSoul: () => exportToSoul,
   generateNPCId: () => generateNPCId,
@@ -46,8 +54,13 @@ __export(index_exports, {
   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,
@@ -63,13 +76,19 @@ __export(index_exports, {
   npcSlice: () => npcSlice,
   pipe: () => pipe,
   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,
@@ -83,17 +102,19 @@ __export(index_exports, {
   setNPCInfo: () => setNPCInfo,
   setNPCState: () => setNPCState,
   soulSlice: () => soulSlice,
-  speakNPC: () => speakNPC,
   startGhostThunk: () => startGhostThunk,
   stopGhostThunk: () => stopGhostThunk,
   store: () => store,
+  storeMemoryRemoteThunk: () => storeMemoryRemoteThunk,
   streamFromCortex: () => streamFromCortex,
   streamFromCortexWithDelay: () => streamFromCortexWithDelay,
   streamToCallback: () => streamToCallback,
   streamToString: () => streamToString,
   updateNPCState: () => updateNPCState,
   updateNPCStateLocally: () => updateNPCStateLocally,
-  validateBridgeThunk: () => validateBridgeThunk
+  validateBridgeThunk: () => validateBridgeThunk,
+  verdictValidated: () => verdictValidated,
+  verifySoulThunk: () => verifySoulThunk
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -125,8 +146,28 @@ var sdkApi = (0, import_query.createApi)({
       return headers;
     }
   }),
-  tagTypes: ["NPC", "Memory", "Cortex", "Ghost", "Soul", "Bridge"],
+  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 }) => ({
@@ -169,88 +210,214 @@ var sdkApi = (0, import_query.createApi)({
         };
       }
     }),
-    postSpeak: builder.mutation({
+    postMemoryStore: builder.mutation({
       query: ({ npcId, request, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/npcs/${npcId}/speak`,
+        url: `${apiUrl}/npcs/${npcId}/memory`,
         method: "POST",
         headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
         body: request
       }),
-      invalidatesTags: (result, error, { npcId }) => [{ type: "NPC", id: npcId }],
+      invalidatesTags: (result, error, { npcId }) => [{ type: "Memory", id: npcId }],
       transformResponse: (response) => response
     }),
-    postDialogue: builder.mutation({
+    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}/dialogue`,
+        url: `${apiUrl}/npcs/${npcId}/memory/recall`,
         method: "POST",
         headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
         body: request
       }),
-      invalidatesTags: (result, error, { npcId }) => [{ type: "NPC", id: npcId }],
+      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 }) => ({ url: `${apiUrl}/ghost/run`, method: "POST", body: request }),
+      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 }) => ({ url: `${apiUrl}/ghost/${sessionId}/status`, method: "GET" }),
+      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 }) => ({ url: `${apiUrl}/ghost/${sessionId}/results`, method: "GET" }),
+      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 }) => ({ url: `${apiUrl}/ghost/${sessionId}/stop`, method: "POST" }),
+      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: true })
+      transformResponse: (response) => ({
+        stopped: response?.stopStatus === "stopped",
+        stopStatus: response?.stopStatus,
+        stopSessionId: response?.stopSessionId
+      })
     }),
     getGhostHistory: builder.query({
-      query: ({ limit, apiUrl }) => ({ url: `${apiUrl}/ghost/history?limit=${limit}`, method: "GET" }),
+      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 }) => ({ url: `${apiUrl}/npcs/${npcId}/soul/export`, method: "POST", body: request }),
+      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 }) => ({ url: `${apiUrl}/souls/${txId}`, method: "GET" }),
+      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 }) => ({ url: `${apiUrl}/souls?limit=${limit}`, method: "GET" }),
+      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 }) => ({
+      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 }) => ({ url: `${apiUrl}/rules`, method: "GET" }),
+      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 }) => ({ url: `${apiUrl}/rules/presets/${presetName}`, method: "POST" }),
+      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 }) => ({
@@ -273,19 +440,22 @@ var sdkApi = (0, import_query.createApi)({
 // src/bridgeSlice.ts
 var initialState = {
   activePresets: [],
+  availableRulesets: [],
+  availablePresetIds: [],
   lastValidation: null,
   status: "idle",
   error: null
 };
 var validateBridgeThunk = (0, import_toolkit.createAsyncThunk)(
   "bridge/validate",
-  async ({ action, context, npcId, apiUrl }, { dispatch: dispatch2, rejectWithValue }) => {
+  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
+        apiUrl: url,
+        apiKey
       })).unwrap();
       return data;
     } catch (e) {
@@ -295,10 +465,10 @@ var validateBridgeThunk = (0, import_toolkit.createAsyncThunk)(
 );
 var loadBridgePresetThunk = (0, import_toolkit.createAsyncThunk)(
   "bridge/loadPreset",
-  async ({ presetName, apiUrl }, { dispatch: dispatch2, rejectWithValue }) => {
+  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 })).unwrap();
+      return await dispatch2(sdkApi.endpoints.postBridgePreset.initiate({ presetName, apiUrl: url, apiKey })).unwrap();
     } catch (e) {
       return rejectWithValue(e.message || "Failed to load preset");
     }
@@ -306,15 +476,59 @@ var loadBridgePresetThunk = (0, import_toolkit.createAsyncThunk)(
 );
 var getBridgeRulesThunk = (0, import_toolkit.createAsyncThunk)(
   "bridge/rules",
-  async ({ apiUrl }, { dispatch: dispatch2, rejectWithValue }) => {
+  async ({ apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
       const url = apiUrl || "https://api.forboc.ai";
-      return await dispatch2(sdkApi.endpoints.getBridgeRules.initiate({ apiUrl: url })).unwrap();
+      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,
@@ -348,6 +562,10 @@ var bridgeSlice = (0, import_toolkit.createSlice)({
       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;
     });
   }
 });
@@ -366,7 +584,7 @@ var initialState2 = {
 };
 var remoteExportSoulThunk = (0, import_toolkit2.createAsyncThunk)(
   "soul/export",
-  async ({ npcId: argNpcId, apiUrl, memories = [] }, { getState, dispatch: dispatch2, rejectWithValue }) => {
+  async ({ npcId: argNpcId, apiUrl, apiKey, memories = [] }, { getState, dispatch: dispatch2, rejectWithValue }) => {
     try {
       const state = getState().npc;
       const npcId = argNpcId || state.activeNpcId;
@@ -376,7 +594,8 @@ var remoteExportSoulThunk = (0, import_toolkit2.createAsyncThunk)(
       const result = await dispatch2(sdkApi.endpoints.postSoulExport.initiate({
         npcId,
         request: { npcIdRef: npcId, persona: npc.persona || "NPC", npcState: npc.state },
-        apiUrl: url
+        apiUrl: url,
+        apiKey
       })).unwrap();
       return {
         txId: result.txId,
@@ -390,10 +609,10 @@ var remoteExportSoulThunk = (0, import_toolkit2.createAsyncThunk)(
 );
 var importSoulFromArweaveThunk = (0, import_toolkit2.createAsyncThunk)(
   "soul/import",
-  async ({ txId, apiUrl }, { dispatch: dispatch2, rejectWithValue }) => {
+  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 })).unwrap();
+      const data = await dispatch2(sdkApi.endpoints.getSoulImport.initiate({ txId, apiUrl: url, apiKey })).unwrap();
       return data;
     } catch (e) {
       return rejectWithValue(e.message || "Soul import failed");
@@ -402,16 +621,42 @@ var importSoulFromArweaveThunk = (0, import_toolkit2.createAsyncThunk)(
 );
 var getSoulListThunk = (0, import_toolkit2.createAsyncThunk)(
   "soul/list",
-  async ({ limit = 50, apiUrl }, { dispatch: dispatch2, rejectWithValue }) => {
+  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 })).unwrap();
+      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,
@@ -469,7 +714,8 @@ var startGhostThunk = (0, import_toolkit3.createAsyncThunk)(
       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
+        apiUrl,
+        apiKey: config.apiKey
       })).unwrap();
       return {
         sessionId: data.sessionId,
@@ -482,13 +728,13 @@ var startGhostThunk = (0, import_toolkit3.createAsyncThunk)(
 );
 var getGhostStatusThunk = (0, import_toolkit3.createAsyncThunk)(
   "ghost/status",
-  async ({ sessionId, apiUrl }, { dispatch: dispatch2, getState, rejectWithValue }) => {
+  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 })).unwrap();
+      const data = await dispatch2(sdkApi.endpoints.getGhostStatus.initiate({ sessionId: targetSession, apiUrl: url, apiKey })).unwrap();
       return {
         sessionId: data.ghostSessionId,
         status: data.ghostStatus,
@@ -504,13 +750,13 @@ var getGhostStatusThunk = (0, import_toolkit3.createAsyncThunk)(
 );
 var getGhostResultsThunk = (0, import_toolkit3.createAsyncThunk)(
   "ghost/results",
-  async ({ sessionId, apiUrl }, { dispatch: dispatch2, getState, rejectWithValue }) => {
+  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 })).unwrap();
+      const data = await dispatch2(sdkApi.endpoints.getGhostResults.initiate({ sessionId: targetSession, apiUrl: url, apiKey })).unwrap();
       return {
         sessionId: data.resultsSessionId,
         totalTests: data.resultsTotalTests,
@@ -535,25 +781,29 @@ var getGhostResultsThunk = (0, import_toolkit3.createAsyncThunk)(
 );
 var stopGhostThunk = (0, import_toolkit3.createAsyncThunk)(
   "ghost/stop",
-  async ({ sessionId, apiUrl }, { dispatch: dispatch2, getState, rejectWithValue }) => {
+  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";
-      await dispatch2(sdkApi.endpoints.postGhostStop.initiate({ sessionId: targetSession, apiUrl: url })).unwrap();
-      return { stopped: true };
+      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 { stopped: true };
+      return rejectWithValue(e.message || "Failed to stop ghost session");
     }
   }
 );
 var getGhostHistoryThunk = (0, import_toolkit3.createAsyncThunk)(
   "ghost/history",
-  async ({ limit = 10, apiUrl }, { dispatch: dispatch2, rejectWithValue }) => {
+  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 })).unwrap();
+      const data = await dispatch2(sdkApi.endpoints.getGhostHistory.initiate({ limit, apiUrl: url, apiKey })).unwrap();
       return (data.sessions || []).map((s) => ({
         sessionId: s.sessionId,
         testSuite: s.testSuite,
@@ -596,8 +846,14 @@ var ghostSlice = (0, import_toolkit3.createSlice)({
     }).addCase(getGhostResultsThunk.fulfilled, (state, action) => {
       state.results = action.payload;
       state.status = "completed";
-    }).addCase(stopGhostThunk.fulfilled, (state) => {
-      state.status = "failed";
+    }).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;
     });
@@ -606,11 +862,19 @@ var ghostSlice = (0, import_toolkit3.createSlice)({
 var { clearGhostSession } = ghostSlice.actions;
 var ghostSlice_default = ghostSlice.reducer;
 
-// src/utils.ts
-var SDK_VERSION = "0.5.9";
+// src/utils/sdkVersion.ts
+var SDK_VERSION = "0.6.0";
+
+// src/utils/generateNPCId.ts
 var generateNPCId = () => `ag_${Date.now().toString(36)}`;
+
+// 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;
@@ -624,6 +888,8 @@ var memoiseAsync = (fn) => {
     return promise;
   };
 };
+
+// src/utils/memoise.ts
 var memoise = (fn) => {
   let cached = null;
   let initialized = false;
@@ -660,7 +926,7 @@ var streamFromCortexWithDelay = async (cortex, prompt, onChunk, options) => {
 };
 
 // src/store.ts
-var import_toolkit8 = require("@reduxjs/toolkit");
+var import_toolkit9 = require("@reduxjs/toolkit");
 
 // src/npcSlice.ts
 var import_toolkit4 = require("@reduxjs/toolkit");
@@ -760,13 +1026,34 @@ var initialState4 = {
 };
 var initRemoteCortexThunk = (0, import_toolkit5.createAsyncThunk)(
   "cortex/initRemote",
-  async ({ model = "api-integrated" }) => {
-    return {
-      id: `remote_${Date.now()}`,
-      model,
-      ready: true,
-      engine: "remote"
-    };
+  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)(
@@ -885,15 +1172,108 @@ var selectLastRecalledMemories = (state) => {
 };
 var memorySlice_default = memorySlice.reducer;
 
-// src/listeners.ts
+// src/directiveSlice.ts
 var import_toolkit7 = require("@reduxjs/toolkit");
-var sdkListenerMiddleware = (0, import_toolkit7.createListenerMiddleware)();
+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();
-    if (action.payload === state.npc.activeNpcId) {
+    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());
     }
   }
@@ -901,12 +1281,13 @@ startAppListening({
 
 // src/store.ts
 var createSDKStore = (extraReducers = {}) => {
-  return (0, import_toolkit8.configureStore)({
+  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,
@@ -922,128 +1303,184 @@ var store = createSDKStore();
 var dispatch = store.dispatch;
 
 // src/thunks.ts
-var import_toolkit9 = require("@reduxjs/toolkit");
-var processNPC = (0, import_toolkit9.createAsyncThunk)(
+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 }) => {
+  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: persona || "Default" }));
+      dispatch2(setNPCInfo({ id: argNpcId, persona }));
     }
-    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, {
+    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
       });
-    } 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));
+      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));
     }
-    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)(
+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().catch(() => []) : [];
+    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,
   addToHistory,
   blockAction,
   bridgeSlice,
+  checkApiStatusThunk,
   clearBlock,
   clearBridgeValidation,
+  clearDirectivesForNpc,
   clearGhostSession,
+  clearMemoryRemoteThunk,
   clearSoulState,
   completeRemoteThunk,
+  contextComposed,
   cortexInitFailed,
   cortexInitStart,
   cortexInitSuccess,
@@ -1051,7 +1488,11 @@ var localExportSoulThunk = (0, import_toolkit9.createAsyncThunk)(
   createInitialState,
   createSDKStore,
   delay,
-  dialogueNPC,
+  deleteRulesetThunk,
+  directiveReceived,
+  directiveRunFailed,
+  directiveRunStarted,
+  directiveSlice,
   dispatch,
   exportToSoul,
   generateNPCId,
@@ -1061,8 +1502,13 @@ var localExportSoulThunk = (0, import_toolkit9.createAsyncThunk)(
   getGhostStatusThunk,
   getSoulListThunk,
   ghostSlice,
+  importNpcFromSoulThunk,
   importSoulFromArweaveThunk,
   initRemoteCortexThunk,
+  listCortexModelsThunk,
+  listMemoryRemoteThunk,
+  listRulePresetsThunk,
+  listRulesetsThunk,
   loadBridgePresetThunk,
   localExportSoulThunk,
   memoise,
@@ -1078,13 +1524,19 @@ var localExportSoulThunk = (0, import_toolkit9.createAsyncThunk)(
   npcSlice,
   pipe,
   processNPC,
+  recallMemoryRemoteThunk,
+  registerRulesetThunk,
   remoteExportSoulThunk,
   removeNPC,
   sdkApi,
+  selectActiveDirective,
+  selectActiveDirectiveId,
   selectActiveNPC,
   selectActiveNpcId,
+  selectAllDirectives,
   selectAllMemories,
   selectAllNPCs,
+  selectDirectiveById,
   selectLastRecalledMemories,
   selectMemoryById,
   selectNPCById,
@@ -1098,15 +1550,17 @@ var localExportSoulThunk = (0, import_toolkit9.createAsyncThunk)(
   setNPCInfo,
   setNPCState,
   soulSlice,
-  speakNPC,
   startGhostThunk,
   stopGhostThunk,
   store,
+  storeMemoryRemoteThunk,
   streamFromCortex,
   streamFromCortexWithDelay,
   streamToCallback,
   streamToString,
   updateNPCState,
   updateNPCStateLocally,
-  validateBridgeThunk
+  validateBridgeThunk,
+  verdictValidated,
+  verifySoulThunk
 });