@forbocai/core 0.6.0 → 0.6.2

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,9 +146,44 @@ 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
+    /**
+     * User Story: As the SDK protocol loop, I need a single process endpoint
+     * that returns one atomic instruction per turn while echoing full tape state.
+     * ᚹ one hop in, one hop out, like passing a lit shard through vacuum.
+     */
+    postNpcProcess: builder.mutation({
+      query: ({ npcId, request, apiUrl, apiKey }) => ({
+        url: `${apiUrl}/npcs/${npcId}/process`,
+        method: "POST",
+        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
+        body: request
+      }),
+      invalidatesTags: (result, error, { npcId }) => [{ type: "NPC", id: npcId }],
+      transformResponse: (response) => response
+    }),
     postDirective: builder.mutation({
       query: ({ npcId, request, apiUrl, apiKey }) => ({
         url: `${apiUrl}/npcs/${npcId}/directive`,
@@ -169,88 +225,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 +455,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 +480,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 +491,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 +577,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 +599,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 +609,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 +624,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 +636,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 +729,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 +743,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 +765,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 +796,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 +861,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 +877,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.1";
+
+// 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 +903,8 @@ var memoiseAsync = (fn) => {
     return promise;
   };
 };
+
+// src/utils/memoise.ts
 var memoise = (fn) => {
   let cached = null;
   let initialized = false;
@@ -660,7 +941,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 +1041,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 +1187,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 +1296,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 +1318,241 @@ 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 extractThunkErrorMessage = (e) => {
+  if (typeof e === "string") return e;
+  if (e?.data?.message) return String(e.data.message);
+  if (e?.error) return String(e.error);
+  if (e?.message) return String(e.message);
+  return "Protocol processing failed";
+};
+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 (argNpcId && argNpcId !== stateNpcId) {
-      dispatch2(setNPCInfo({ id: argNpcId, persona: persona || "Default" }));
-    }
-    const directiveResult = await dispatch2(
-      sdkApi.endpoints.postDirective.initiate({ npcId, request: { observation: text, npcState: currentState, context }, apiUrl, apiKey })
-    ).unwrap();
-    const recalledMemories = memory && directiveResult.memoryRecall ? await memory.recall(
-      directiveResult.memoryRecall.query,
-      directiveResult.memoryRecall.limit,
-      directiveResult.memoryRecall.threshold
-    ).then((mems) => mems.map((m) => ({ text: m.text, type: m.type, importance: m.importance }))).catch(() => []) : [];
-    const contextResult = await dispatch2(
-      sdkApi.endpoints.postContext.initiate({ npcId, request: { memories: recalledMemories, observation: text, npcState: currentState, persona: persona || "Default" }, apiUrl, apiKey })
-    ).unwrap();
-    let generatedText = "";
-    if (cortex) {
-      generatedText = await cortex.complete(contextResult.prompt, {
-        maxTokens: contextResult.constraints.maxTokens,
-        temperature: contextResult.constraints.temperature,
-        stop: contextResult.constraints.stop
-      });
-    } else {
-      const remoteResult = await dispatch2(sdkApi.endpoints.postCortexComplete.initiate({
-        cortexId: "remote",
-        // Or generic
-        prompt: contextResult.prompt,
-        options: contextResult.constraints,
-        apiUrl,
-        apiKey
-      })).unwrap();
-      generatedText = remoteResult.text || "";
+    if (!npcId) {
+      return rejectWithValue("No npcId provided and no active NPC selected");
     }
-    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 (!persona) {
+      return rejectWithValue("No persona provided and no active NPC persona available");
     }
-    if (memory && verdictResult.memoryStore) {
-      for (const inst of verdictResult.memoryStore) {
-        await memory.store(inst.text, inst.type, inst.importance).catch((e) => console.warn("Memory store failed:", e));
-      }
+    if (!cortex) {
+      return rejectWithValue("No local cortex provided. SDK remote cortex fallback is disabled.");
     }
-    if (verdictResult.stateDelta) {
-      dispatch2(updateNPCState({ id: npcId, delta: verdictResult.stateDelta }));
+    if (argNpcId && argNpcId !== stateNpcId) {
+      dispatch2(setNPCInfo({ id: argNpcId, persona }));
     }
-    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 }));
+    const directiveId = `${npcId}:${Date.now()}`;
+    dispatch2(directiveRunStarted({ id: directiveId, npcId, observation: text }));
+    try {
+      const initialTape = {
+        observation: text,
+        context,
+        npcState: currentState,
+        persona,
+        memories: [],
+        vectorQueried: false
+      };
+      const maxTurns = 12;
+      const persistMemoryInstructionsRecursively = async (instructions, index = 0) => {
+        if (!memory || index >= instructions.length) {
+          return;
+        }
+        const inst = instructions[index];
+        await memory.store(inst.text, inst.type, inst.importance);
+        await persistMemoryInstructionsRecursively(instructions, index + 1);
+      };
+      const runProtocolRecursively = async (tape, lastResult, turn) => {
+        if (turn >= maxTurns) {
+          return rejectWithValue(`Protocol loop exceeded max turns (${maxTurns})`);
+        }
+        const request = { tape, lastResult };
+        const processResult = await dispatch2(
+          sdkApi.endpoints.postNpcProcess.initiate({ npcId, request, apiUrl, apiKey })
+        ).unwrap();
+        const nextTape = processResult.tape;
+        const instruction = processResult.instruction;
+        if (instruction.type === "IdentifyActor") {
+          return runProtocolRecursively(nextTape, {
+            type: "IdentifyActorResult",
+            actor: {
+              npcId,
+              persona,
+              data: nextTape.npcState
+            }
+          }, turn + 1);
+        }
+        if (instruction.type === "QueryVector") {
+          dispatch2(directiveReceived({
+            id: directiveId,
+            response: { memoryRecall: { query: instruction.query, limit: instruction.limit, threshold: instruction.threshold } }
+          }));
+          if (!memory) {
+            return rejectWithValue("API requested memory recall, but no memory engine is configured");
+          }
+          const recalled = await memory.recall(instruction.query, instruction.limit, instruction.threshold);
+          return runProtocolRecursively(nextTape, {
+            type: "QueryVectorResult",
+            memories: recalled.map((m) => ({ text: m.text, type: m.type, importance: m.importance, similarity: m.similarity }))
+          }, turn + 1);
+        }
+        if (instruction.type === "ExecuteInference") {
+          dispatch2(contextComposed({ id: directiveId, prompt: instruction.prompt, constraints: instruction.constraints }));
+          const generatedText = await cortex.complete(instruction.prompt, {
+            maxTokens: instruction.constraints.maxTokens,
+            temperature: instruction.constraints.temperature,
+            stop: instruction.constraints.stop
+          });
+          return runProtocolRecursively(nextTape, {
+            type: "ExecuteInferenceResult",
+            generatedOutput: generatedText
+          }, turn + 1);
+        }
+        if (instruction.type === "Finalize") {
+          const finalize = instruction;
+          dispatch2(verdictValidated({
+            id: directiveId,
+            verdict: {
+              valid: finalize.valid,
+              signature: finalize.signature,
+              memoryStore: finalize.memoryStore,
+              stateDelta: finalize.stateTransform,
+              action: finalize.action,
+              dialogue: finalize.dialogue
+            }
+          }));
+          if (!finalize.valid) {
+            dispatch2(blockAction({ id: npcId, reason: finalize.dialogue || "Validation Failed" }));
+            return {
+              dialogue: finalize.dialogue,
+              action: finalize.action,
+              thought: finalize.dialogue
+            };
+          }
+          if (finalize.memoryStore?.length && !memory) {
+            return rejectWithValue("API returned memoryStore instructions, but no memory engine is configured");
+          }
+          await persistMemoryInstructionsRecursively(finalize.memoryStore || []);
+          if (finalize.stateTransform) {
+            dispatch2(updateNPCState({ id: npcId, delta: finalize.stateTransform }));
+          }
+          dispatch2(setLastAction({ id: npcId, action: finalize.action }));
+          dispatch2(addToHistory({ id: npcId, role: "user", content: text }));
+          dispatch2(addToHistory({ id: npcId, role: "assistant", content: finalize.dialogue }));
+          return {
+            dialogue: finalize.dialogue,
+            action: finalize.action,
+            thought: finalize.dialogue
+          };
+        }
+        return rejectWithValue("API returned unknown instruction type");
+      };
+      return runProtocolRecursively(initialTape, void 0, 0);
+    } catch (e) {
+      const message = extractThunkErrorMessage(e);
+      dispatch2(directiveRunFailed({ id: directiveId, error: String(message) }));
+      return rejectWithValue(String(message));
     }
-    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 +1560,11 @@ var localExportSoulThunk = (0, import_toolkit9.createAsyncThunk)(
   createInitialState,
   createSDKStore,
   delay,
-  dialogueNPC,
+  deleteRulesetThunk,
+  directiveReceived,
+  directiveRunFailed,
+  directiveRunStarted,
+  directiveSlice,
   dispatch,
   exportToSoul,
   generateNPCId,
@@ -1061,8 +1574,13 @@ var localExportSoulThunk = (0, import_toolkit9.createAsyncThunk)(
   getGhostStatusThunk,
   getSoulListThunk,
   ghostSlice,
+  importNpcFromSoulThunk,
   importSoulFromArweaveThunk,
   initRemoteCortexThunk,
+  listCortexModelsThunk,
+  listMemoryRemoteThunk,
+  listRulePresetsThunk,
+  listRulesetsThunk,
   loadBridgePresetThunk,
   localExportSoulThunk,
   memoise,
@@ -1078,13 +1596,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 +1622,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
 });