@forbocai/core 0.6.2 → 0.6.4

package/dist/index.js

@@ -20,10 +20,15 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  SDK_VERSION: () => SDK_VERSION,
+  DEFAULT_API_URL: () => DEFAULT_API_URL,
+  PRODUCTION_API_URL: () => PRODUCTION_API_URL,
+  VERSION: () => VERSION,
+  _: () => _,
   addToHistory: () => addToHistory,
+  api: () => api,
   blockAction: () => blockAction,
   bridgeSlice: () => bridgeSlice,
+  checkApiConnectivity: () => checkApiConnectivity,
   checkApiStatusThunk: () => checkApiStatusThunk,
   clearBlock: () => clearBlock,
   clearBridgeValidation: () => clearBridgeValidation,
@@ -32,13 +37,17 @@ __export(index_exports, {
   clearMemoryRemoteThunk: () => clearMemoryRemoteThunk,
   clearSoulState: () => clearSoulState,
   completeRemoteThunk: () => completeRemoteThunk,
+  compose: () => compose,
   contextComposed: () => contextComposed,
   cortexInitFailed: () => cortexInitFailed,
   cortexInitStart: () => cortexInitStart,
   cortexInitSuccess: () => cortexInitSuccess,
   cortexSlice: () => cortexSlice,
+  createDispatcher: () => createDispatcher,
   createInitialState: () => createInitialState,
-  createSDKStore: () => createSDKStore,
+  createRuntimeRegistry: () => createRuntimeRegistry,
+  createRuntimeStore: () => createRuntimeStore,
+  curry: () => curry,
   delay: () => delay,
   deleteRulesetThunk: () => deleteRulesetThunk,
   directiveReceived: () => directiveReceived,
@@ -46,7 +55,12 @@ __export(index_exports, {
   directiveRunStarted: () => directiveRunStarted,
   directiveSlice: () => directiveSlice,
   dispatch: () => dispatch,
+  ebind: () => ebind,
+  efmap: () => efmap,
+  ematch: () => ematch,
   exportToSoul: () => exportToSoul,
+  fmap: () => fmap,
+  fromNullable: () => fromNullable,
   generateNPCId: () => generateNPCId,
   getBridgeRulesThunk: () => getBridgeRulesThunk,
   getGhostHistoryThunk: () => getGhostHistoryThunk,
@@ -54,15 +68,25 @@ __export(index_exports, {
   getGhostStatusThunk: () => getGhostStatusThunk,
   getSoulListThunk: () => getSoulListThunk,
   ghostSlice: () => ghostSlice,
+  handler_ArweaveDownload: () => handler_ArweaveDownload,
+  handler_ArweaveUpload: () => handler_ArweaveUpload,
   importNpcFromSoulThunk: () => importNpcFromSoulThunk,
   importSoulFromArweaveThunk: () => importSoulFromArweaveThunk,
   initRemoteCortexThunk: () => initRemoteCortexThunk,
+  isJust: () => isJust,
+  isLeft: () => isLeft,
+  isNothing: () => isNothing,
+  isRight: () => isRight,
+  just: () => just,
+  left: () => left,
   listCortexModelsThunk: () => listCortexModelsThunk,
   listMemoryRemoteThunk: () => listMemoryRemoteThunk,
   listRulePresetsThunk: () => listRulePresetsThunk,
   listRulesetsThunk: () => listRulesetsThunk,
   loadBridgePresetThunk: () => loadBridgePresetThunk,
   localExportSoulThunk: () => localExportSoulThunk,
+  match: () => match,
+  mbind: () => mbind,
   memoise: () => memoise,
   memoiseAsync: () => memoiseAsync,
   memoryClear: () => memoryClear,
@@ -73,14 +97,21 @@ __export(index_exports, {
   memoryStoreFailed: () => memoryStoreFailed,
   memoryStoreStart: () => memoryStoreStart,
   memoryStoreSuccess: () => memoryStoreSuccess,
+  multiMatch: () => multiMatch,
+  nothing: () => nothing,
   npcSlice: () => npcSlice,
+  orElse: () => orElse,
   pipe: () => pipe,
   processNPC: () => processNPC,
   recallMemoryRemoteThunk: () => recallMemoryRemoteThunk,
   registerRulesetThunk: () => registerRulesetThunk,
   remoteExportSoulThunk: () => remoteExportSoulThunk,
   removeNPC: () => removeNPC,
-  sdkApi: () => sdkApi,
+  requireJust: () => requireJust,
+  resolveApiUrl: () => resolveApiUrl,
+  resolveApiUrlWithFallback: () => resolveApiUrlWithFallback,
+  resolveReachableApiUrl: () => resolveReachableApiUrl,
+  right: () => right,
   selectActiveDirective: () => selectActiveDirective,
   selectActiveDirectiveId: () => selectActiveDirectiveId,
   selectActiveNPC: () => selectActiveNPC,
@@ -138,320 +169,461 @@ var import_toolkit = require("@reduxjs/toolkit");
 
 // src/apiSlice.ts
 var import_query = require("@reduxjs/toolkit/query");
-var sdkApi = (0, import_query.createApi)({
-  reducerPath: "forbocApi",
-  baseQuery: (0, import_query.fetchBaseQuery)({
-    baseUrl: "/",
-    prepareHeaders: (headers, { getState }) => {
-      return headers;
-    }
+
+// src/api/endpoints/arweave.ts
+var buildArweaveEndpoints = (builder) => ({
+  postArweaveUpload: builder.mutation({
+    queryFn: async (instruction) => {
+      const maxRetries = instruction.maxRetries ?? 3;
+      const headers = {
+        "Content-Type": instruction.auiContentType || "application/json"
+      };
+      const walletToken = typeof globalThis !== "undefined" ? globalThis.process?.env?.ARWEAVE_WALLET_JWK ?? null : null;
+      const authToken = instruction.auiAuthHeader ?? (walletToken ? `Bearer ${walletToken}` : null);
+      if (authToken) headers.Authorization = authToken;
+      const attempt = async (n) => {
+        try {
+          const controller = new AbortController();
+          const timeout = setTimeout(() => controller.abort(), 6e4);
+          const response = await fetch(instruction.auiEndpoint, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(instruction.auiPayload),
+            signal: controller.signal
+          });
+          clearTimeout(timeout);
+          const responseBody = await response.json().catch(() => null);
+          const txId = responseBody?.id ?? `ar_tx_sdk_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+          const success = response.status >= 200 && response.status < 300;
+          return !success && n + 1 < maxRetries ? new Promise((resolve) => setTimeout(() => resolve(attempt(n + 1)), 250 * 2 ** n)) : {
+            data: {
+              aurTxId: txId,
+              aurStatus: response.status,
+              aurSuccess: success,
+              aurError: success ? null : `upload_failed_status_${response.status}`
+            }
+          };
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          return n + 1 < maxRetries ? new Promise((resolve) => setTimeout(() => resolve(attempt(n + 1)), 250 * 2 ** n)) : {
+            data: {
+              aurTxId: `ar_tx_failed_${Date.now()}`,
+              aurStatus: 0,
+              aurSuccess: false,
+              aurError: `upload_request_failed:${message}`
+            }
+          };
+        }
+      };
+      return attempt(0);
+    },
+    invalidatesTags: ["Soul"]
   }),
-  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 || []
+  postArweaveDownload: builder.mutation({
+    queryFn: async (instruction) => {
+      try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 6e4);
+        const response = await fetch(instruction.adiGatewayUrl, { method: "GET", signal: controller.signal });
+        clearTimeout(timeout);
+        return response.status < 200 || response.status >= 300 ? { data: { adrBody: null, adrStatus: response.status, adrSuccess: false, adrError: `download_failed_status_${response.status}` } } : response.json().then((body) => ({ data: { adrBody: body, adrStatus: response.status, adrSuccess: true, adrError: null } })).catch(() => ({ data: { adrBody: null, adrStatus: response.status, adrSuccess: false, adrError: "download_invalid_json" } }));
+      } catch (error) {
+        return {
+          data: {
+            adrBody: null,
+            adrStatus: 0,
+            adrSuccess: false,
+            adrError: error instanceof Error ? error.message : String(error)
+          }
+        };
+      }
+    },
+    invalidatesTags: ["Soul"]
+  })
+});
+
+// src/api/endpoints/builder.ts
+var authHeaders = (apiKey) => apiKey ? { Authorization: `Bearer ${apiKey}` } : {};
+
+// src/api/endpoints/cortex.ts
+var buildCortexEndpoints = (builder) => ({
+  getCortexModels: builder.query({
+    query: ({ apiUrl, apiKey }) => ({
+      url: `${apiUrl}/cortex/models`,
+      method: "GET",
+      headers: authHeaders(apiKey)
     }),
-    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
+    providesTags: ["Cortex"],
+    transformResponse: (response) => response || []
+  }),
+  postCortexInit: builder.mutation({
+    query: ({ request, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/cortex/init`,
+      method: "POST",
+      headers: authHeaders(apiKey),
+      body: request
     }),
-    // 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
+    invalidatesTags: ["Cortex"],
+    transformResponse: (response) => response
+  }),
+  postCortexComplete: builder.mutation({
+    query: ({ cortexId, prompt, options, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/cortex/${cortexId}/complete`,
+      method: "POST",
+      headers: authHeaders(apiKey),
+      body: { prompt, ...options }
     }),
-    postDirective: builder.mutation({
-      query: ({ npcId, request, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/npcs/${npcId}/directive`,
-        method: "POST",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
-        body: request
-      }),
-      invalidatesTags: ["NPC"],
-      transformResponse: (response) => response
+    invalidatesTags: ["Cortex"],
+    transformResponse: (response) => response
+  })
+});
+
+// src/api/endpoints/ghost.ts
+var ghostTag = (sessionId) => [{ type: "Ghost", id: sessionId }];
+var buildGhostEndpoints = (builder) => ({
+  postGhostRun: builder.mutation({
+    query: ({ request, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/ghost/run`,
+      method: "POST",
+      headers: authHeaders(apiKey),
+      body: request
     }),
-    postContext: builder.mutation({
-      query: ({ npcId, request, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/npcs/${npcId}/context`,
-        method: "POST",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
-        body: request
-      }),
-      invalidatesTags: (result, error, { npcId }) => [{ type: "NPC", id: npcId }],
-      transformResponse: (response) => response
+    invalidatesTags: ["Ghost"],
+    transformResponse: (response) => response
+  }),
+  getGhostStatus: builder.query({
+    query: ({ sessionId, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/ghost/${sessionId}/status`,
+      method: "GET",
+      headers: authHeaders(apiKey)
     }),
-    postVerdict: builder.mutation({
-      query: ({ npcId, request, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/npcs/${npcId}/verdict`,
-        method: "POST",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
-        body: request
-      }),
-      invalidatesTags: (result, error, { npcId }) => [{ type: "NPC", id: npcId }],
-      transformResponse: (response) => {
-        const action = response.action ? {
-          type: response.action.gaType || response.action.type,
-          reason: response.action.actionReason || response.action.reason,
-          target: response.action.actionTarget || response.action.target,
-          signature: response.action.signature
-        } : void 0;
-        return {
-          ...response,
-          action
-        };
-      }
+    providesTags: (_result, _error, { sessionId }) => ghostTag(sessionId),
+    transformResponse: (response) => response
+  }),
+  getGhostResults: builder.query({
+    query: ({ sessionId, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/ghost/${sessionId}/results`,
+      method: "GET",
+      headers: authHeaders(apiKey)
     }),
-    postMemoryStore: builder.mutation({
-      query: ({ npcId, request, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/npcs/${npcId}/memory`,
-        method: "POST",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
-        body: request
-      }),
-      invalidatesTags: (result, error, { npcId }) => [{ type: "Memory", id: npcId }],
-      transformResponse: (response) => response
+    providesTags: (_result, _error, { sessionId }) => ghostTag(sessionId),
+    transformResponse: (response) => response
+  }),
+  postGhostStop: builder.mutation({
+    query: ({ sessionId, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/ghost/${sessionId}/stop`,
+      method: "POST",
+      headers: authHeaders(apiKey)
     }),
-    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 || []
+    invalidatesTags: (_result, _error, { sessionId }) => ghostTag(sessionId),
+    transformResponse: (response) => ({
+      stopped: response?.stopStatus === "stopped",
+      stopStatus: response?.stopStatus,
+      stopSessionId: response?.stopSessionId
+    })
+  }),
+  getGhostHistory: builder.query({
+    query: ({ limit, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/ghost/history?limit=${limit}`,
+      method: "GET",
+      headers: authHeaders(apiKey)
     }),
-    postMemoryRecall: builder.mutation({
-      query: ({ npcId, request, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/npcs/${npcId}/memory/recall`,
-        method: "POST",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
-        body: request
-      }),
-      invalidatesTags: (result, error, { npcId }) => [{ type: "Memory", id: npcId }],
-      transformResponse: (response) => response || []
+    providesTags: ["Ghost"],
+    transformResponse: (response) => response
+  })
+});
+
+// src/api/endpoints/npc.ts
+var memoryTag = (npcId) => [{ type: "Memory", id: npcId }];
+var npcTag = (npcId) => [{ type: "NPC", id: npcId }];
+var buildNpcEndpoints = (builder) => ({
+  postNpcProcess: builder.mutation({
+    query: ({ npcId, request, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/npcs/${npcId}/process`,
+      method: "POST",
+      headers: authHeaders(apiKey),
+      body: request
     }),
-    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
+    invalidatesTags: (_result, _error, { npcId }) => npcTag(npcId),
+    transformResponse: (response) => response
+  }),
+  postDirective: builder.mutation({
+    query: ({ npcId, request, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/npcs/${npcId}/directive`,
+      method: "POST",
+      headers: authHeaders(apiKey),
+      body: request
     }),
-    // Ghost Endpoints
-    postGhostRun: builder.mutation({
-      query: ({ request, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/ghost/run`,
-        method: "POST",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
-        body: request
-      }),
-      invalidatesTags: ["Ghost"],
-      transformResponse: (response) => response
+    invalidatesTags: ["NPC"],
+    transformResponse: (response) => response
+  }),
+  postContext: builder.mutation({
+    query: ({ npcId, request, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/npcs/${npcId}/context`,
+      method: "POST",
+      headers: authHeaders(apiKey),
+      body: request
     }),
-    getGhostStatus: builder.query({
-      query: ({ sessionId, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/ghost/${sessionId}/status`,
-        method: "GET",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
-      }),
-      providesTags: (result, error, { sessionId }) => [{ type: "Ghost", id: sessionId }],
-      transformResponse: (response) => response
+    invalidatesTags: (_result, _error, { npcId }) => npcTag(npcId),
+    transformResponse: (response) => response
+  }),
+  postVerdict: builder.mutation({
+    query: ({ npcId, request, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/npcs/${npcId}/verdict`,
+      method: "POST",
+      headers: authHeaders(apiKey),
+      body: request
     }),
-    getGhostResults: builder.query({
-      query: ({ sessionId, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/ghost/${sessionId}/results`,
-        method: "GET",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
-      }),
-      providesTags: (result, error, { sessionId }) => [{ type: "Ghost", id: sessionId }],
-      transformResponse: (response) => response
+    invalidatesTags: (_result, _error, { npcId }) => npcTag(npcId),
+    transformResponse: (response) => {
+      const action = response.action ? {
+        type: response.action.gaType || response.action.type,
+        reason: response.action.actionReason || response.action.reason,
+        target: response.action.actionTarget || response.action.target,
+        signature: response.action.signature
+      } : void 0;
+      return {
+        ...response,
+        action
+      };
+    }
+  }),
+  postMemoryStore: builder.mutation({
+    query: ({ npcId, request, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/npcs/${npcId}/memory`,
+      method: "POST",
+      headers: authHeaders(apiKey),
+      body: request
     }),
-    postGhostStop: builder.mutation({
-      query: ({ sessionId, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/ghost/${sessionId}/stop`,
-        method: "POST",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
-      }),
-      invalidatesTags: (result, error, { sessionId }) => [{ type: "Ghost", id: sessionId }],
-      transformResponse: (response) => ({
-        stopped: response?.stopStatus === "stopped",
-        stopStatus: response?.stopStatus,
-        stopSessionId: response?.stopSessionId
-      })
+    invalidatesTags: (_result, _error, { npcId }) => memoryTag(npcId),
+    transformResponse: (response) => response
+  }),
+  getMemoryList: builder.query({
+    query: ({ npcId, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/npcs/${npcId}/memory`,
+      method: "GET",
+      headers: authHeaders(apiKey)
     }),
-    getGhostHistory: builder.query({
-      query: ({ limit, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/ghost/history?limit=${limit}`,
-        method: "GET",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
-      }),
-      providesTags: ["Ghost"],
-      transformResponse: (response) => response
+    providesTags: (_result, _error, { npcId }) => memoryTag(npcId),
+    transformResponse: (response) => response || []
+  }),
+  postMemoryRecall: builder.mutation({
+    query: ({ npcId, request, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/npcs/${npcId}/memory/recall`,
+      method: "POST",
+      headers: authHeaders(apiKey),
+      body: request
     }),
-    // Soul Endpoints
-    postSoulExport: builder.mutation({
-      query: ({ npcId, request, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/npcs/${npcId}/soul/export`,
-        method: "POST",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
-        body: request
-      }),
-      invalidatesTags: ["Soul"],
-      transformResponse: (response) => response
+    invalidatesTags: (_result, _error, { npcId }) => memoryTag(npcId),
+    transformResponse: (response) => response || []
+  }),
+  deleteMemoryClear: builder.mutation({
+    query: ({ npcId, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/npcs/${npcId}/memory/clear`,
+      method: "DELETE",
+      headers: authHeaders(apiKey)
     }),
-    getSoulImport: builder.query({
-      query: ({ txId, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/souls/${txId}`,
-        method: "GET",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
-      }),
-      providesTags: (result, error, { txId }) => [{ type: "Soul", id: txId }],
-      transformResponse: (response) => response
+    invalidatesTags: (_result, _error, { npcId }) => memoryTag(npcId),
+    transformResponse: (response) => response
+  })
+});
+
+// src/api/endpoints/rules.ts
+var buildBridgeAndRuleEndpoints = (builder) => ({
+  postBridgeValidate: builder.mutation({
+    query: ({ request, npcId, apiUrl, apiKey }) => ({
+      url: npcId ? `${apiUrl}/bridge/validate/${npcId}` : `${apiUrl}/bridge/validate`,
+      method: "POST",
+      headers: authHeaders(apiKey),
+      body: request
     }),
-    getSouls: builder.query({
-      query: ({ limit, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/souls?limit=${limit}`,
-        method: "GET",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
-      }),
-      providesTags: ["Soul"],
-      transformResponse: (response) => response
+    invalidatesTags: ["Bridge"],
+    transformResponse: (response) => response.brResult || response
+  }),
+  getBridgeRules: builder.query({
+    query: ({ apiUrl, apiKey }) => ({
+      url: `${apiUrl}/bridge/rules`,
+      method: "GET",
+      headers: authHeaders(apiKey)
     }),
-    // Bridge Endpoints
-    postBridgeValidate: builder.mutation({
-      query: ({ request, npcId, apiUrl, apiKey }) => ({
-        url: npcId ? `${apiUrl}/bridge/validate/${npcId}` : `${apiUrl}/bridge/validate`,
-        method: "POST",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
-        body: request
-      }),
-      invalidatesTags: ["Bridge"],
-      transformResponse: (response) => response.brResult || response
+    providesTags: ["Bridge"],
+    transformResponse: (response) => response
+  }),
+  postBridgePreset: builder.mutation({
+    query: ({ presetName, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/rules/presets/${presetName}`,
+      method: "POST",
+      headers: authHeaders(apiKey)
     }),
-    getBridgeRules: builder.query({
-      query: ({ apiUrl, apiKey }) => ({
-        url: `${apiUrl}/bridge/rules`,
-        method: "GET",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
-      }),
-      providesTags: ["Bridge"],
-      transformResponse: (response) => response
+    invalidatesTags: ["Bridge"],
+    transformResponse: (response) => response
+  }),
+  getRulesets: builder.query({
+    query: ({ apiUrl, apiKey }) => ({
+      url: `${apiUrl}/rules`,
+      method: "GET",
+      headers: authHeaders(apiKey)
     }),
-    postBridgePreset: builder.mutation({
-      query: ({ presetName, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/rules/presets/${presetName}`,
-        method: "POST",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
-      }),
-      invalidatesTags: ["Bridge"],
-      transformResponse: (response) => response
+    providesTags: ["Rule"],
+    transformResponse: (response) => response || []
+  }),
+  getRulePresets: builder.query({
+    query: ({ apiUrl, apiKey }) => ({
+      url: `${apiUrl}/rules/presets`,
+      method: "GET",
+      headers: authHeaders(apiKey)
     }),
-    // Rules Endpoints
-    getRulesets: builder.query({
-      query: ({ apiUrl, apiKey }) => ({
-        url: `${apiUrl}/rules`,
-        method: "GET",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
-      }),
-      providesTags: ["Rule"],
-      transformResponse: (response) => response || []
+    providesTags: ["Rule"],
+    transformResponse: (response) => response || []
+  }),
+  postRuleRegister: builder.mutation({
+    query: ({ request, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/rules`,
+      method: "POST",
+      headers: authHeaders(apiKey),
+      body: request
     }),
-    getRulePresets: builder.query({
-      query: ({ apiUrl, apiKey }) => ({
-        url: `${apiUrl}/rules/presets`,
-        method: "GET",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
-      }),
-      providesTags: ["Rule"],
-      transformResponse: (response) => response || []
+    invalidatesTags: ["Rule"],
+    transformResponse: (response) => response
+  }),
+  deleteRule: builder.mutation({
+    query: ({ rulesetId, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/rules/${rulesetId}`,
+      method: "DELETE",
+      headers: authHeaders(apiKey)
     }),
-    postRuleRegister: builder.mutation({
-      query: ({ request, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/rules`,
-        method: "POST",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
-        body: request
-      }),
-      invalidatesTags: ["Rule"],
-      transformResponse: (response) => response
+    invalidatesTags: ["Rule"],
+    transformResponse: (_response) => ({ deleted: true })
+  })
+});
+
+// src/api/endpoints/soul.ts
+var soulTag = (id) => [{ type: "Soul", id }];
+var buildSoulEndpoints = (builder) => ({
+  postSoulExport: builder.mutation({
+    query: ({ npcId, request, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/npcs/${npcId}/soul/export`,
+      method: "POST",
+      headers: authHeaders(apiKey),
+      body: request
     }),
-    deleteRule: builder.mutation({
-      query: ({ rulesetId, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/rules/${rulesetId}`,
-        method: "DELETE",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
-      }),
-      invalidatesTags: ["Rule"],
-      transformResponse: (_response) => ({ deleted: true })
+    invalidatesTags: ["Soul"],
+    transformResponse: (response) => response
+  }),
+  postSoulExportConfirm: builder.mutation({
+    query: ({ npcId, request, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/npcs/${npcId}/soul/confirm`,
+      method: "POST",
+      headers: authHeaders(apiKey),
+      body: request
     }),
-    // 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
-      })
+    invalidatesTags: ["Soul"],
+    transformResponse: (response) => response
+  }),
+  getSoulImport: builder.query({
+    query: ({ txId, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/souls/${txId}`,
+      method: "GET",
+      headers: authHeaders(apiKey)
     }),
-    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
+    providesTags: (_result, _error, { txId }) => soulTag(txId),
+    transformResponse: (response) => response
+  }),
+  getSouls: builder.query({
+    query: ({ limit, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/souls?limit=${limit}`,
+      method: "GET",
+      headers: authHeaders(apiKey)
     }),
-    // Cortex Remote Endpoint
-    postCortexComplete: builder.mutation({
-      query: ({ cortexId, prompt, options, apiUrl, apiKey }) => ({
-        url: `${apiUrl}/cortex/${cortexId}/complete`,
-        method: "POST",
-        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
-        body: { prompt, ...options }
-      }),
-      invalidatesTags: ["Cortex"],
-      transformResponse: (response) => response
+    providesTags: ["Soul"],
+    transformResponse: (response) => response
+  }),
+  postSoulVerify: builder.mutation({
+    query: ({ txId, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/souls/${txId}/verify`,
+      method: "POST",
+      headers: authHeaders(apiKey)
     }),
-    // System Endpoints
-    getApiStatus: builder.query({
-      query: ({ apiUrl }) => ({ url: `${apiUrl}/status`, method: "GET" }),
-      transformResponse: (response) => response
+    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: authHeaders(apiKey),
+      body: request
+    }),
+    invalidatesTags: ["NPC"],
+    transformResponse: (response) => response
+  }),
+  postNpcImportConfirm: builder.mutation({
+    query: ({ request, apiUrl, apiKey }) => ({
+      url: `${apiUrl}/npcs/import/confirm`,
+      method: "POST",
+      headers: authHeaders(apiKey),
+      body: request
+    }),
+    invalidatesTags: ["NPC"],
+    transformResponse: (response) => response
+  })
+});
+
+// src/api/endpoints/system.ts
+var buildSystemEndpoints = (builder) => ({
+  getApiStatus: builder.query({
+    query: ({ apiUrl }) => ({ url: `${apiUrl}/status`, method: "GET" }),
+    providesTags: ["NPC"],
+    transformResponse: (response) => response
+  })
+});
+
+// src/apiSlice.ts
+var api = (0, import_query.createApi)({
+  reducerPath: "api",
+  baseQuery: (0, import_query.fetchBaseQuery)({
+    baseUrl: "/",
+    prepareHeaders: (headers, { getState }) => {
+      return headers;
+    }
+  }),
+  tagTypes: ["NPC", "Memory", "Cortex", "Ghost", "Soul", "Bridge", "Rule"],
+  endpoints: (builder) => ({
+    ...buildCortexEndpoints(builder),
+    ...buildNpcEndpoints(builder),
+    ...buildGhostEndpoints(builder),
+    ...buildSoulEndpoints(builder),
+    ...buildBridgeAndRuleEndpoints(builder),
+    ...buildArweaveEndpoints(builder),
+    ...buildSystemEndpoints(builder)
   })
 });
 
+// src/errors.ts
+var DEFAULT_API_URL = "http://localhost:8080";
+var PRODUCTION_API_URL = "https://api.forboc.ai";
+var resolveApiUrl = (apiUrl) => apiUrl || DEFAULT_API_URL;
+var extractThunkErrorMessage = (error, fallback) => {
+  if (typeof error === "string") return error;
+  if (error && typeof error === "object") {
+    const e = error;
+    if (typeof e.data === "object" && e.data?.message) return String(e.data.message);
+    if (typeof e.data === "string") return e.data;
+    if (e.message) return e.message;
+    if (e.error) return e.error;
+  }
+  return fallback;
+};
+var requireApiKeyGuidance = (apiUrl, apiKey) => {
+  const normalized = apiUrl.toLowerCase();
+  if (normalized.includes("api.forboc.ai") && !apiKey) {
+    throw new Error("Missing API key. Set FORBOCAI_API_KEY (or run `forboc config set apiKey <key>`) for production API calls.");
+  }
+};
+
 // src/bridgeSlice.ts
 var initialState = {
   activePresets: [],
@@ -465,16 +637,17 @@ var validateBridgeThunk = (0, import_toolkit.createAsyncThunk)(
   "bridge/validate",
   async ({ action, context, npcId, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
-      const url = apiUrl || "https://api.forboc.ai";
-      const data = await dispatch2(sdkApi.endpoints.postBridgeValidate.initiate({
+      const url = resolveApiUrl(apiUrl);
+      requireApiKeyGuidance(url, apiKey);
+      const data = await dispatch2(api.endpoints.postBridgeValidate.initiate({
         request: { action, context },
         npcId,
         apiUrl: url,
         apiKey
       })).unwrap();
       return data;
-    } catch (e) {
-      return rejectWithValue(e.message || "Bridge validation failed");
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Bridge validation failed"));
     }
   }
 );
@@ -482,10 +655,11 @@ var loadBridgePresetThunk = (0, import_toolkit.createAsyncThunk)(
   "bridge/loadPreset",
   async ({ presetName, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
-      const url = apiUrl || "https://api.forboc.ai";
-      return await dispatch2(sdkApi.endpoints.postBridgePreset.initiate({ presetName, apiUrl: url, apiKey })).unwrap();
-    } catch (e) {
-      return rejectWithValue(e.message || "Failed to load preset");
+      const url = resolveApiUrl(apiUrl);
+      requireApiKeyGuidance(url, apiKey);
+      return await dispatch2(api.endpoints.postBridgePreset.initiate({ presetName, apiUrl: url, apiKey })).unwrap();
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Failed to load preset"));
     }
   }
 );
@@ -493,10 +667,11 @@ var getBridgeRulesThunk = (0, import_toolkit.createAsyncThunk)(
   "bridge/rules",
   async ({ apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
-      const url = apiUrl || "https://api.forboc.ai";
-      return await dispatch2(sdkApi.endpoints.getBridgeRules.initiate({ apiUrl: url, apiKey })).unwrap();
-    } catch (e) {
-      return rejectWithValue(e.message || "Failed to list bridge rules");
+      const url = resolveApiUrl(apiUrl);
+      requireApiKeyGuidance(url, apiKey);
+      return await dispatch2(api.endpoints.getBridgeRules.initiate({ apiUrl: url, apiKey })).unwrap();
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Failed to list bridge rules"));
     }
   }
 );
@@ -504,10 +679,11 @@ 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");
+      const url = resolveApiUrl(apiUrl);
+      requireApiKeyGuidance(url, apiKey);
+      return await dispatch2(api.endpoints.getRulesets.initiate({ apiUrl: url, apiKey })).unwrap();
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Failed to list rulesets"));
     }
   }
 );
@@ -515,10 +691,11 @@ 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");
+      const url = resolveApiUrl(apiUrl);
+      requireApiKeyGuidance(url, apiKey);
+      return await dispatch2(api.endpoints.getRulePresets.initiate({ apiUrl: url, apiKey })).unwrap();
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Failed to list rule presets"));
     }
   }
 );
@@ -526,10 +703,11 @@ 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");
+      const url = resolveApiUrl(apiUrl);
+      requireApiKeyGuidance(url, apiKey);
+      return await dispatch2(api.endpoints.postRuleRegister.initiate({ request: ruleset, apiUrl: url, apiKey })).unwrap();
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Failed to register ruleset"));
     }
   }
 );
@@ -537,10 +715,11 @@ 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");
+      const url = resolveApiUrl(apiUrl);
+      requireApiKeyGuidance(url, apiKey);
+      return await dispatch2(api.endpoints.deleteRule.initiate({ rulesetId, apiUrl: url, apiKey })).unwrap();
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Failed to delete ruleset"));
     }
   }
 );
@@ -589,6 +768,85 @@ var bridgeSlice_default = bridgeSlice.reducer;
 
 // src/soulSlice.ts
 var import_toolkit2 = require("@reduxjs/toolkit");
+
+// src/functional_core.ts
+var just = (value) => ({
+  _tag: "Just",
+  map: (f) => just(f(value)),
+  chain: (f) => f(value),
+  getOrElse: (_defaultValue) => value,
+  match: (cases) => cases.just(value)
+});
+var nothing = () => ({
+  _tag: "Nothing",
+  map: (_f) => nothing(),
+  chain: (_f) => nothing(),
+  getOrElse: (defaultValue) => defaultValue,
+  match: (cases) => cases.nothing()
+});
+var fmap = (m, f) => m.map(f);
+var mbind = (m, f) => m.chain(f);
+var orElse = (m, defaultValue) => m.getOrElse(defaultValue);
+var match = (m, onJust, onNothing) => m.match({ just: onJust, nothing: onNothing });
+var isJust = (m) => m._tag === "Just";
+var isNothing = (m) => m._tag === "Nothing";
+var fromNullable = (value) => value != null ? just(value) : nothing();
+var requireJust = (m, errorMsg) => m.match({
+  just: (v) => v,
+  nothing: () => {
+    throw new Error(errorMsg);
+  }
+});
+var left = (error) => ({
+  _tag: "Left",
+  map: (_f) => left(error),
+  chain: (_f) => left(error),
+  getOrElse: (defaultValue) => defaultValue,
+  match: (cases) => cases.left(error)
+});
+var right = (value) => ({
+  _tag: "Right",
+  map: (f) => right(f(value)),
+  chain: (f) => f(value),
+  getOrElse: (_defaultValue) => value,
+  match: (cases) => cases.right(value)
+});
+var efmap = (e, f) => e.map(f);
+var ebind = (e, f) => e.chain(f);
+var ematch = (e, onLeft, onRight) => e.match({ left: onLeft, right: onRight });
+var isLeft = (e) => e._tag === "Left";
+var isRight = (e) => e._tag === "Right";
+function compose(...fns) {
+  return (...args) => {
+    const last = fns[fns.length - 1];
+    const rest = fns.slice(0, -1);
+    return rest.reduceRight((acc, fn) => fn(acc), last(...args));
+  };
+}
+function curry(fn) {
+  const arity = fn.length;
+  const curried = (...args) => args.length >= arity ? fn(...args) : (...moreArgs) => curried(...args, ...moreArgs);
+  return curried;
+}
+var createDispatcher = (entries) => {
+  const table = new Map(entries);
+  return {
+    dispatch: (key, ...args) => {
+      const handler = table.get(key);
+      return handler ? just(handler(...args)) : nothing();
+    },
+    has: (key) => table.has(key),
+    keys: () => [...table.keys()]
+  };
+};
+var _ = /* @__PURE__ */ Symbol.for("forbocai_wildcard");
+var testCase = (value, predicate, handler) => predicate === _ ? just(handler(value)) : typeof predicate === "function" ? predicate(value) ? just(handler(value)) : nothing() : predicate === value ? just(handler(value)) : nothing();
+var multiMatch = (value, cases) => cases.length === 0 ? nothing() : testCase(value, cases[0][0], cases[0][1]).match({
+  just: (v) => just(v),
+  nothing: () => multiMatch(value, cases.slice(1))
+});
+
+// src/soulSlice.ts
 var initialState2 = {
   exportStatus: "idle",
   importStatus: "idle",
@@ -599,26 +857,46 @@ var initialState2 = {
 };
 var remoteExportSoulThunk = (0, import_toolkit2.createAsyncThunk)(
   "soul/export",
-  async ({ npcId: argNpcId, apiUrl, apiKey, memories = [] }, { getState, dispatch: dispatch2, rejectWithValue }) => {
+  async ({ npcId: argNpcId, apiUrl, apiKey }, { getState, dispatch: dispatch2, rejectWithValue }) => {
     try {
       const state = getState().npc;
       const npcId = argNpcId || state.activeNpcId;
-      const npc = state.entities[npcId];
-      if (!npc) throw new Error(`NPC ${npcId} not found`);
-      const url = apiUrl || "https://api.forboc.ai";
-      const result = await dispatch2(sdkApi.endpoints.postSoulExport.initiate({
-        npcId,
-        request: { npcIdRef: npcId, persona: npc.persona || "NPC", npcState: npc.state },
-        apiUrl: url,
-        apiKey
-      })).unwrap();
+      const npc = requireJust(fromNullable(state.entities[npcId]), `NPC ${npcId} not found`);
+      const url = resolveApiUrl(apiUrl);
+      requireApiKeyGuidance(url, apiKey);
+      const phase1 = await dispatch2(
+        api.endpoints.postSoulExport.initiate({
+          npcId,
+          request: { npcIdRef: npcId, persona: npc.persona || "NPC", npcState: npc.state },
+          apiUrl: url,
+          apiKey
+        })
+      ).unwrap();
+      const uploadResult = await dispatch2(
+        api.endpoints.postArweaveUpload.initiate({
+          ...phase1.se1Instruction,
+          auiAuthHeader: phase1.se1Instruction.auiAuthHeader ?? null
+        })
+      ).unwrap();
+      const final = await dispatch2(
+        api.endpoints.postSoulExportConfirm.initiate({
+          npcId,
+          request: {
+            secUploadResult: uploadResult,
+            secSignedPayload: phase1.se1SignedPayload,
+            secSignature: phase1.se1Signature
+          },
+          apiUrl: url,
+          apiKey
+        })
+      ).unwrap();
       return {
-        txId: result.txId,
-        url: result.arweaveUrl,
-        soul: result.soul
+        txId: final.txId,
+        url: final.arweaveUrl,
+        soul: final.soul
       };
-    } catch (e) {
-      return rejectWithValue(e.message || "Soul export failed");
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Soul export failed"));
     }
   }
 );
@@ -626,11 +904,34 @@ var importSoulFromArweaveThunk = (0, import_toolkit2.createAsyncThunk)(
   "soul/import",
   async ({ txId, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
-      const url = apiUrl || "https://api.forboc.ai";
-      const data = await dispatch2(sdkApi.endpoints.getSoulImport.initiate({ txId, apiUrl: url, apiKey })).unwrap();
-      return data;
-    } catch (e) {
-      return rejectWithValue(e.message || "Soul import failed");
+      const url = resolveApiUrl(apiUrl);
+      requireApiKeyGuidance(url, apiKey);
+      const phase1 = await dispatch2(
+        api.endpoints.postNpcImport.initiate({ request: { txIdRef: txId }, apiUrl: url, apiKey })
+      ).unwrap();
+      const downloadResult = await dispatch2(
+        api.endpoints.postArweaveDownload.initiate(phase1.si1Instruction)
+      ).unwrap();
+      const npc = await dispatch2(
+        api.endpoints.postNpcImportConfirm.initiate({
+          request: {
+            sicTxId: txId,
+            sicDownloadResult: downloadResult
+          },
+          apiUrl: url,
+          apiKey
+        })
+      ).unwrap();
+      return {
+        id: txId,
+        version: "2.0.0",
+        name: npc.npcId,
+        persona: npc.persona,
+        memories: [],
+        state: npc.data || {}
+      };
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Soul import failed"));
     }
   }
 );
@@ -638,11 +939,12 @@ var getSoulListThunk = (0, import_toolkit2.createAsyncThunk)(
   "soul/list",
   async ({ limit = 50, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
-      const url = apiUrl || "https://api.forboc.ai";
-      const data = await dispatch2(sdkApi.endpoints.getSouls.initiate({ limit, apiUrl: url, apiKey })).unwrap();
+      const url = resolveApiUrl(apiUrl);
+      requireApiKeyGuidance(url, apiKey);
+      const data = await dispatch2(api.endpoints.getSouls.initiate({ limit, apiUrl: url, apiKey })).unwrap();
       return data.souls || [];
-    } catch (e) {
-      return rejectWithValue(e.message || "Failed to list souls");
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Failed to list souls"));
     }
   }
 );
@@ -650,10 +952,11 @@ 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");
+      const url = resolveApiUrl(apiUrl);
+      requireApiKeyGuidance(url, apiKey);
+      return await dispatch2(api.endpoints.postSoulVerify.initiate({ txId, apiUrl: url, apiKey })).unwrap();
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Soul verify failed"));
     }
   }
 );
@@ -661,14 +964,27 @@ 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");
+      const url = resolveApiUrl(apiUrl);
+      requireApiKeyGuidance(url, apiKey);
+      const phase1 = await dispatch2(
+        api.endpoints.postNpcImport.initiate({
+          request: { txIdRef: txId },
+          apiUrl: url,
+          apiKey
+        })
+      ).unwrap();
+      const downloadResult = await dispatch2(
+        api.endpoints.postArweaveDownload.initiate(phase1.si1Instruction)
+      ).unwrap();
+      return await dispatch2(
+        api.endpoints.postNpcImportConfirm.initiate({
+          request: { sicTxId: txId, sicDownloadResult: downloadResult },
+          apiUrl: url,
+          apiKey
+        })
+      ).unwrap();
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "NPC import from soul failed"));
     }
   }
 );
@@ -726,8 +1042,9 @@ var startGhostThunk = (0, import_toolkit3.createAsyncThunk)(
   "ghost/start",
   async (config, { dispatch: dispatch2, rejectWithValue }) => {
     try {
-      const apiUrl = config.apiUrl || "https://api.forboc.ai";
-      const data = await dispatch2(sdkApi.endpoints.postGhostRun.initiate({
+      const apiUrl = resolveApiUrl(config.apiUrl);
+      requireApiKeyGuidance(apiUrl, config.apiKey);
+      const data = await dispatch2(api.endpoints.postGhostRun.initiate({
         request: { testSuite: config.testSuite, duration: config.duration ?? 300 },
         apiUrl,
         apiKey: config.apiKey
@@ -736,8 +1053,8 @@ var startGhostThunk = (0, import_toolkit3.createAsyncThunk)(
         sessionId: data.sessionId,
         status: data.runStatus
       };
-    } catch (e) {
-      return rejectWithValue(e.message || "Failed to start Ghost");
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Failed to start Ghost"));
     }
   }
 );
@@ -746,10 +1063,10 @@ var getGhostStatusThunk = (0, import_toolkit3.createAsyncThunk)(
   async ({ sessionId, apiUrl, apiKey }, { dispatch: dispatch2, getState, rejectWithValue }) => {
     try {
       const state = getState().ghost;
-      const targetSession = sessionId || state.activeSessionId;
-      if (!targetSession) throw new Error("No active Ghost session");
-      const url = apiUrl || "https://api.forboc.ai";
-      const data = await dispatch2(sdkApi.endpoints.getGhostStatus.initiate({ sessionId: targetSession, apiUrl: url, apiKey })).unwrap();
+      const targetSession = requireJust(fromNullable(sessionId || state.activeSessionId), "No active Ghost session");
+      const url = resolveApiUrl(apiUrl);
+      requireApiKeyGuidance(url, apiKey);
+      const data = await dispatch2(api.endpoints.getGhostStatus.initiate({ sessionId: targetSession, apiUrl: url, apiKey })).unwrap();
       return {
         sessionId: data.ghostSessionId,
         status: data.ghostStatus,
@@ -758,8 +1075,8 @@ var getGhostStatusThunk = (0, import_toolkit3.createAsyncThunk)(
         duration: data.ghostDuration || 0,
         errors: data.ghostErrors
       };
-    } catch (e) {
-      return rejectWithValue(e.message || "Failed to get ghost status");
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Failed to get ghost status"));
     }
   }
 );
@@ -768,10 +1085,10 @@ var getGhostResultsThunk = (0, import_toolkit3.createAsyncThunk)(
   async ({ sessionId, apiUrl, apiKey }, { dispatch: dispatch2, getState, rejectWithValue }) => {
     try {
       const state = getState().ghost;
-      const targetSession = sessionId || state.activeSessionId;
-      if (!targetSession) throw new Error("No active Ghost session");
-      const url = apiUrl || "https://api.forboc.ai";
-      const data = await dispatch2(sdkApi.endpoints.getGhostResults.initiate({ sessionId: targetSession, apiUrl: url, apiKey })).unwrap();
+      const targetSession = requireJust(fromNullable(sessionId || state.activeSessionId), "No active Ghost session");
+      const url = resolveApiUrl(apiUrl);
+      requireApiKeyGuidance(url, apiKey);
+      const data = await dispatch2(api.endpoints.getGhostResults.initiate({ sessionId: targetSession, apiUrl: url, apiKey })).unwrap();
       return {
         sessionId: data.resultsSessionId,
         totalTests: data.resultsTotalTests,
@@ -789,8 +1106,8 @@ var getGhostResultsThunk = (0, import_toolkit3.createAsyncThunk)(
         coverage: data.resultsCoverage,
         metrics: Object.fromEntries(data.resultsMetrics || [])
       };
-    } catch (e) {
-      return rejectWithValue(e.message || "Failed to get ghost results");
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Failed to get ghost results"));
     }
   }
 );
@@ -799,17 +1116,17 @@ var stopGhostThunk = (0, import_toolkit3.createAsyncThunk)(
   async ({ sessionId, apiUrl, apiKey }, { dispatch: dispatch2, getState, rejectWithValue }) => {
     try {
       const state = getState().ghost;
-      const targetSession = sessionId || state.activeSessionId;
-      if (!targetSession) throw new Error("No active Ghost session");
-      const url = apiUrl || "https://api.forboc.ai";
-      const data = await dispatch2(sdkApi.endpoints.postGhostStop.initiate({ sessionId: targetSession, apiUrl: url, apiKey })).unwrap();
+      const targetSession = requireJust(fromNullable(sessionId || state.activeSessionId), "No active Ghost session");
+      const url = resolveApiUrl(apiUrl);
+      requireApiKeyGuidance(url, apiKey);
+      const data = await dispatch2(api.endpoints.postGhostStop.initiate({ sessionId: targetSession, apiUrl: url, apiKey })).unwrap();
       return {
         stopped: data.stopped,
         status: data.stopStatus,
         sessionId: data.stopSessionId
       };
-    } catch (e) {
-      return rejectWithValue(e.message || "Failed to stop ghost session");
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Failed to stop ghost session"));
     }
   }
 );
@@ -817,8 +1134,9 @@ var getGhostHistoryThunk = (0, import_toolkit3.createAsyncThunk)(
   "ghost/history",
   async ({ limit = 10, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
-      const url = apiUrl || "https://api.forboc.ai";
-      const data = await dispatch2(sdkApi.endpoints.getGhostHistory.initiate({ limit, apiUrl: url, apiKey })).unwrap();
+      const url = resolveApiUrl(apiUrl);
+      requireApiKeyGuidance(url, apiKey);
+      const data = await dispatch2(api.endpoints.getGhostHistory.initiate({ limit, apiUrl: url, apiKey })).unwrap();
       return (data.sessions || []).map((s) => ({
         sessionId: s.sessionId,
         testSuite: s.testSuite,
@@ -827,8 +1145,8 @@ var getGhostHistoryThunk = (0, import_toolkit3.createAsyncThunk)(
         status: s.status,
         passRate: s.passRate
       }));
-    } catch (e) {
-      return rejectWithValue(e.message || "Failed to get ghost history");
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Failed to get ghost history"));
     }
   }
 );
@@ -863,7 +1181,7 @@ var ghostSlice = (0, import_toolkit3.createSlice)({
       state.status = "completed";
     }).addCase(stopGhostThunk.fulfilled, (state, action) => {
       if (action.payload.stopped) {
-        state.status = "failed";
+        state.status = "completed";
       } else {
         state.error = action.payload.status || "Ghost stop request did not stop a session";
       }
@@ -877,8 +1195,8 @@ var ghostSlice = (0, import_toolkit3.createSlice)({
 var { clearGhostSession } = ghostSlice.actions;
 var ghostSlice_default = ghostSlice.reducer;
 
-// src/utils/sdkVersion.ts
-var SDK_VERSION = "0.6.1";
+// src/utils/version.ts
+var VERSION = "0.6.4";
 
 // src/utils/generateNPCId.ts
 var generateNPCId = () => `ag_${Date.now().toString(36)}`;
@@ -959,7 +1277,8 @@ var npcSlice = (0, import_toolkit4.createSlice)({
         persona,
         state: initialState5 || {},
         history: [],
-        isBlocked: false
+        isBlocked: false,
+        stateLog: [{ timestamp: Date.now(), delta: initialState5 || {}, state: initialState5 || {} }]
       });
       state.activeNpcId = id;
     },
@@ -974,7 +1293,9 @@ var npcSlice = (0, import_toolkit4.createSlice)({
       const { id, delta } = action.payload;
       const npc = state.entities[id];
       if (npc) {
-        npc.state = { ...npc.state, ...delta };
+        const newState = { ...npc.state, ...delta };
+        npc.state = newState;
+        npc.stateLog.push({ timestamp: Date.now(), delta, state: newState });
       }
     },
     addToHistory: (state, action) => {
@@ -1043,8 +1364,9 @@ var initRemoteCortexThunk = (0, import_toolkit5.createAsyncThunk)(
   "cortex/initRemote",
   async ({ model = "api-integrated", authKey, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
-      const url = apiUrl || "https://api.forboc.ai";
-      const data = await dispatch2(sdkApi.endpoints.postCortexInit.initiate({
+      const url = resolveApiUrl(apiUrl);
+      requireApiKeyGuidance(url, apiKey);
+      const data = await dispatch2(api.endpoints.postCortexInit.initiate({
         request: { requestedModel: model, authKey },
         apiUrl: url,
         apiKey
@@ -1055,8 +1377,8 @@ var initRemoteCortexThunk = (0, import_toolkit5.createAsyncThunk)(
         ready: data.state?.toLowerCase() === "ready",
         engine: "remote"
       };
-    } catch (e) {
-      return rejectWithValue(e.message || "Remote cortex init failed");
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Remote cortex init failed"));
     }
   }
 );
@@ -1064,10 +1386,11 @@ 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");
+      const url = resolveApiUrl(apiUrl);
+      requireApiKeyGuidance(url, apiKey);
+      return await dispatch2(api.endpoints.getCortexModels.initiate({ apiUrl: url, apiKey })).unwrap();
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Failed to list cortex models"));
     }
   }
 );
@@ -1075,7 +1398,8 @@ var completeRemoteThunk = (0, import_toolkit5.createAsyncThunk)(
   "cortex/completeRemote",
   async ({ cortexId, prompt, options, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
-      const data = await dispatch2(sdkApi.endpoints.postCortexComplete.initiate({
+      requireApiKeyGuidance(apiUrl, apiKey);
+      const data = await dispatch2(api.endpoints.postCortexComplete.initiate({
         cortexId,
         prompt,
         options,
@@ -1083,8 +1407,8 @@ var completeRemoteThunk = (0, import_toolkit5.createAsyncThunk)(
         apiKey
       })).unwrap();
       return data.text;
-    } catch (e) {
-      return rejectWithValue(e.message || "Remote completing failed");
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Remote completing failed"));
     }
   }
 );
@@ -1276,8 +1600,8 @@ 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();
+var listenerMiddleware = (0, import_toolkit8.createListenerMiddleware)();
+var startAppListening = listenerMiddleware.startListening.withTypes();
 startAppListening({
   actionCreator: removeNPC,
   effect: async (action, listenerApi) => {
@@ -1294,11 +1618,38 @@ startAppListening({
   }
 });
 
+// src/runtimeRegistry.ts
+var createRuntimeRegistry = () => {
+  const _store = {};
+  return {
+    get: (ns, key) => _store[ns]?.[key],
+    set: (ns, key, value) => {
+      if (!_store[ns]) _store[ns] = {};
+      _store[ns][key] = value;
+    },
+    delete: (ns, key) => {
+      if (_store[ns]) {
+        delete _store[ns][key];
+        return true;
+      }
+      return false;
+    },
+    has: (ns, key) => !!(_store[ns]?.[key] !== void 0),
+    clear: (ns) => {
+      if (ns) {
+        delete _store[ns];
+      } else {
+        Object.keys(_store).forEach((k) => delete _store[k]);
+      }
+    }
+  };
+};
+
 // src/store.ts
-var createSDKStore = (extraReducers = {}) => {
+var createRuntimeStore = (extraReducers = {}, registry = createRuntimeRegistry()) => {
   return (0, import_toolkit9.configureStore)({
     reducer: {
-      [sdkApi.reducerPath]: sdkApi.reducer,
+      [api.reducerPath]: api.reducer,
       npc: npcSlice_default,
       cortex: cortexSlice_default,
       memory: memorySlice_default,
@@ -1309,46 +1660,120 @@ var createSDKStore = (extraReducers = {}) => {
       ...extraReducers
     },
     middleware: (getDefaultMiddleware) => getDefaultMiddleware({
-      serializableCheck: false
-      // Allow non-serializable for engine refs in specific slices if needed, though we try to keep them external
-    }).prepend(sdkListenerMiddleware.middleware).concat(sdkApi.middleware)
+      thunk: { extraArgument: registry },
+      serializableCheck: {
+        ignoredActionPaths: [
+          "meta.arg.cortex",
+          "meta.arg.memory",
+          "meta.arg.onProgress",
+          "meta.baseQueryMeta.request",
+          "meta.baseQueryMeta.response"
+        ]
+      }
+    }).prepend(listenerMiddleware.middleware).concat(api.middleware)
   });
 };
-var store = createSDKStore();
+var store = createRuntimeStore();
 var dispatch = store.dispatch;
 
 // src/thunks.ts
 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";
+
+// src/protocolHandlers.ts
+var persistMemoryRecursively = async (memory, instructions, index = 0) => !memory || index >= instructions.length ? void 0 : memory.store(instructions[index].text, instructions[index].type, instructions[index].importance).then(() => persistMemoryRecursively(memory, instructions, index + 1));
+var handleIdentifyActor = (ctx, nextTape, turn) => ctx.recurse(nextTape, {
+  type: "IdentifyActorResult",
+  actor: { npcId: ctx.npcId, persona: ctx.persona, data: nextTape.npcState }
+}, turn + 1);
+var handleQueryVector = async (ctx, instruction, nextTape, turn) => {
+  ctx.dispatch(directiveReceived({
+    id: ctx.directiveId,
+    response: { memoryRecall: { query: instruction.query, limit: instruction.limit, threshold: instruction.threshold } }
+  }));
+  return ctx.memory ? ctx.memory.recall(instruction.query, instruction.limit, instruction.threshold).then((recalled) => ctx.recurse(nextTape, {
+    type: "QueryVectorResult",
+    memories: recalled.map((m) => ({ text: m.text, type: m.type, importance: m.importance, similarity: m.similarity }))
+  }, turn + 1)) : ctx.rejectWithValue("API requested memory recall, but no memory engine is configured");
+};
+var handleExecuteInference = async (ctx, instruction, nextTape, turn) => {
+  ctx.dispatch(contextComposed({ id: ctx.directiveId, prompt: instruction.prompt, constraints: instruction.constraints }));
+  const generatedText = await ctx.cortex.complete(instruction.prompt, {
+    maxTokens: instruction.constraints.maxTokens,
+    temperature: instruction.constraints.temperature,
+    stop: instruction.constraints.stop
+  });
+  return ctx.recurse(nextTape, {
+    type: "ExecuteInferenceResult",
+    generatedOutput: generatedText
+  }, turn + 1);
+};
+var handleFinalize = async (ctx, finalize) => {
+  ctx.dispatch(verdictValidated({
+    id: ctx.directiveId,
+    verdict: {
+      valid: finalize.valid,
+      signature: finalize.signature,
+      memoryStore: finalize.memoryStore,
+      stateDelta: finalize.stateTransform,
+      action: finalize.action,
+      dialogue: finalize.dialogue
+    }
+  }));
+  return finalize.valid ? applyFinalizeSuccess(ctx, finalize) : applyFinalizeBlocked(ctx, finalize);
 };
+var applyFinalizeBlocked = (ctx, finalize) => {
+  ctx.dispatch(blockAction({ id: ctx.npcId, reason: finalize.dialogue || "Validation Failed" }));
+  return { dialogue: finalize.dialogue, action: finalize.action, thought: finalize.dialogue };
+};
+var applyFinalizeSuccess = async (ctx, finalize) => {
+  if (finalize.memoryStore?.length && !ctx.memory) {
+    return ctx.rejectWithValue("API returned memoryStore instructions, but no memory engine is configured");
+  }
+  await persistMemoryRecursively(ctx.memory, finalize.memoryStore || []);
+  if (finalize.stateTransform) {
+    ctx.dispatch(updateNPCState({ id: ctx.npcId, delta: finalize.stateTransform }));
+  }
+  ctx.dispatch(setLastAction({ id: ctx.npcId, action: finalize.action }));
+  ctx.dispatch(addToHistory({ id: ctx.npcId, role: "user", content: ctx.text }));
+  ctx.dispatch(addToHistory({ id: ctx.npcId, role: "assistant", content: finalize.dialogue }));
+  return { dialogue: finalize.dialogue, action: finalize.action, thought: finalize.dialogue };
+};
+var dispatchInstruction = (ctx, instruction, nextTape, turn) => {
+  const handlers = {
+    "IdentifyActor": () => handleIdentifyActor(ctx, nextTape, turn),
+    "QueryVector": () => handleQueryVector(ctx, instruction, nextTape, turn),
+    "ExecuteInference": () => handleExecuteInference(ctx, instruction, nextTape, turn),
+    "Finalize": () => handleFinalize(ctx, instruction)
+  };
+  const handler = handlers[instruction.type];
+  return handler ? handler() : Promise.resolve(ctx.rejectWithValue("API returned unknown instruction type"));
+};
+
+// src/thunks.ts
+var extractThunkErrorMessage2 = (e) => multiMatch(e, [
+  [(e2) => typeof e2 === "string", (e2) => e2],
+  [(e2) => !!e2?.data?.message, (e2) => String(e2.data.message)],
+  [(e2) => !!e2?.error, (e2) => String(e2.error)],
+  [(e2) => !!e2?.message, (e2) => String(e2.message)],
+  [_, () => "Protocol processing failed"]
+]).getOrElse("Protocol processing failed");
+var safeDispatch = async (promise) => promise.then((v) => right(v)).catch((e) => left(extractThunkErrorMessage2(e)));
 var processNPC = (0, import_toolkit10.createAsyncThunk)(
   "npc/process",
   async ({ npcId: argNpcId, text, context = {}, apiUrl, apiKey, memory, cortex, persona: argPersona }, { getState, dispatch: dispatch2, rejectWithValue }) => {
     const stateNpcId = selectActiveNpcId(getState());
     const activeNpc = selectActiveNPC(getState());
-    const npcId = argNpcId || stateNpcId;
-    const persona = argPersona || activeNpc?.persona;
     const currentState = activeNpc?.state || {};
-    if (!npcId) {
-      return rejectWithValue("No npcId provided and no active NPC selected");
-    }
-    if (!persona) {
-      return rejectWithValue("No persona provided and no active NPC persona available");
-    }
-    if (!cortex) {
-      return rejectWithValue("No local cortex provided. SDK remote cortex fallback is disabled.");
-    }
-    if (argNpcId && argNpcId !== stateNpcId) {
-      dispatch2(setNPCInfo({ id: argNpcId, persona }));
-    }
-    const directiveId = `${npcId}:${Date.now()}`;
-    dispatch2(directiveRunStarted({ id: directiveId, npcId, observation: text }));
+    let directiveId;
     try {
+      const npcId = requireJust(fromNullable(argNpcId || stateNpcId), "No npcId provided and no active NPC selected");
+      const persona = requireJust(fromNullable(argPersona || activeNpc?.persona), "No persona provided and no active NPC persona available");
+      requireJust(fromNullable(cortex), "No local cortex provided. SDK remote cortex fallback is disabled.");
+      if (argNpcId && argNpcId !== stateNpcId) {
+        dispatch2(setNPCInfo({ id: argNpcId, persona }));
+      }
+      directiveId = `${npcId}:${Date.now()}`;
+      dispatch2(directiveRunStarted({ id: directiveId, npcId, observation: text }));
       const initialTape = {
         observation: text,
         context,
@@ -1357,104 +1782,33 @@ var processNPC = (0, import_toolkit10.createAsyncThunk)(
         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 runProtocol = async (tape, lastResult, turn) => {
+        if (turn >= 12) {
+          return rejectWithValue("Protocol loop exceeded max turns (12)");
         }
         const request = { tape, lastResult };
         const processResult = await dispatch2(
-          sdkApi.endpoints.postNpcProcess.initiate({ npcId, request, apiUrl, apiKey })
+          api.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");
+        const ctx = {
+          npcId,
+          persona,
+          text,
+          directiveId,
+          memory,
+          cortex,
+          dispatch: dispatch2,
+          rejectWithValue,
+          recurse: runProtocol
+        };
+        return dispatchInstruction(ctx, processResult.instruction, processResult.tape, turn);
       };
-      return runProtocolRecursively(initialTape, void 0, 0);
+      return runProtocol(initialTape, void 0, 0);
     } catch (e) {
-      const message = extractThunkErrorMessage(e);
-      dispatch2(directiveRunFailed({ id: directiveId, error: String(message) }));
+      const message = extractThunkErrorMessage2(e);
+      if (directiveId) {
+        dispatch2(directiveRunFailed({ id: directiveId, error: String(message) }));
+      }
       return rejectWithValue(String(message));
     }
   }
@@ -1464,8 +1818,7 @@ var localExportSoulThunk = (0, import_toolkit10.createAsyncThunk)(
   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 npc = requireJust(fromNullable(state.entities[npcId]), `NPC ${npcId} not found`);
     const memories = memory ? await memory.export() : [];
     return exportToSoul(npcId, "NPC", npc.persona, npc.state, memories);
   }
@@ -1473,77 +1826,99 @@ var localExportSoulThunk = (0, import_toolkit10.createAsyncThunk)(
 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");
-    }
+    const result = await safeDispatch(dispatch2(api.endpoints.getApiStatus.initiate({ apiUrl })).unwrap());
+    return result.match({
+      left: (e) => rejectWithValue(e),
+      right: (v) => v
+    });
   }
 );
 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");
-    }
+    const result = await safeDispatch(dispatch2(api.endpoints.getMemoryList.initiate({ npcId, apiUrl, apiKey })).unwrap());
+    return result.match({
+      left: (e) => rejectWithValue(e),
+      right: (v) => v || []
+    });
   }
 );
 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");
-    }
+    const result = await safeDispatch(dispatch2(
+      api.endpoints.postMemoryRecall.initiate({ npcId, request: { query }, apiUrl, apiKey })
+    ).unwrap());
+    return result.match({
+      left: (e) => rejectWithValue(e),
+      right: (v) => v || []
+    });
   }
 );
 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");
-    }
+    const result = await safeDispatch(dispatch2(
+      api.endpoints.postMemoryStore.initiate({ npcId, request: { observation, importance }, apiUrl, apiKey })
+    ).unwrap());
+    return result.match({
+      left: (e) => rejectWithValue(e),
+      right: (v) => v
+    });
   }
 );
 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");
-    }
+    const result = await safeDispatch(dispatch2(
+      api.endpoints.deleteMemoryClear.initiate({ npcId, apiUrl, apiKey })
+    ).unwrap());
+    return result.match({
+      left: (e) => rejectWithValue(e),
+      right: (v) => v
+    });
   }
 );
+
+// src/handlers/arweave.ts
+var handler_ArweaveUpload = async (instruction, maxRetries = 3) => store.dispatch(
+  api.endpoints.postArweaveUpload.initiate({ ...instruction, maxRetries })
+).unwrap();
+var handler_ArweaveDownload = async (instruction) => store.dispatch(
+  api.endpoints.postArweaveDownload.initiate(instruction)
+).unwrap();
+
+// src/configOps.ts
+var normalizeStatusUrl = (apiUrl) => apiUrl.endsWith("/status") ? apiUrl : `${apiUrl.replace(/\/+$/, "")}/status`;
+var checkApiConnectivity = async (apiUrl = DEFAULT_API_URL) => {
+  try {
+    const res = await fetch(normalizeStatusUrl(apiUrl), { signal: AbortSignal.timeout(1500) });
+    return res.ok;
+  } catch {
+    return false;
+  }
+};
+var resolveReachableApiUrl = async (apiUrl) => {
+  if (apiUrl) return await checkApiConnectivity(apiUrl) ? apiUrl : null;
+  if (await checkApiConnectivity(DEFAULT_API_URL)) return DEFAULT_API_URL;
+  if (await checkApiConnectivity(PRODUCTION_API_URL)) return PRODUCTION_API_URL;
+  return null;
+};
+var resolveApiUrlWithFallback = async (apiUrl) => {
+  if (apiUrl) return apiUrl;
+  return await resolveReachableApiUrl() || PRODUCTION_API_URL;
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  SDK_VERSION,
+  DEFAULT_API_URL,
+  PRODUCTION_API_URL,
+  VERSION,
+  _,
   addToHistory,
+  api,
   blockAction,
   bridgeSlice,
+  checkApiConnectivity,
   checkApiStatusThunk,
   clearBlock,
   clearBridgeValidation,
@@ -1552,13 +1927,17 @@ var clearMemoryRemoteThunk = (0, import_toolkit10.createAsyncThunk)(
   clearMemoryRemoteThunk,
   clearSoulState,
   completeRemoteThunk,
+  compose,
   contextComposed,
   cortexInitFailed,
   cortexInitStart,
   cortexInitSuccess,
   cortexSlice,
+  createDispatcher,
   createInitialState,
-  createSDKStore,
+  createRuntimeRegistry,
+  createRuntimeStore,
+  curry,
   delay,
   deleteRulesetThunk,
   directiveReceived,
@@ -1566,7 +1945,12 @@ var clearMemoryRemoteThunk = (0, import_toolkit10.createAsyncThunk)(
   directiveRunStarted,
   directiveSlice,
   dispatch,
+  ebind,
+  efmap,
+  ematch,
   exportToSoul,
+  fmap,
+  fromNullable,
   generateNPCId,
   getBridgeRulesThunk,
   getGhostHistoryThunk,
@@ -1574,15 +1958,25 @@ var clearMemoryRemoteThunk = (0, import_toolkit10.createAsyncThunk)(
   getGhostStatusThunk,
   getSoulListThunk,
   ghostSlice,
+  handler_ArweaveDownload,
+  handler_ArweaveUpload,
   importNpcFromSoulThunk,
   importSoulFromArweaveThunk,
   initRemoteCortexThunk,
+  isJust,
+  isLeft,
+  isNothing,
+  isRight,
+  just,
+  left,
   listCortexModelsThunk,
   listMemoryRemoteThunk,
   listRulePresetsThunk,
   listRulesetsThunk,
   loadBridgePresetThunk,
   localExportSoulThunk,
+  match,
+  mbind,
   memoise,
   memoiseAsync,
   memoryClear,
@@ -1593,14 +1987,21 @@ var clearMemoryRemoteThunk = (0, import_toolkit10.createAsyncThunk)(
   memoryStoreFailed,
   memoryStoreStart,
   memoryStoreSuccess,
+  multiMatch,
+  nothing,
   npcSlice,
+  orElse,
   pipe,
   processNPC,
   recallMemoryRemoteThunk,
   registerRulesetThunk,
   remoteExportSoulThunk,
   removeNPC,
-  sdkApi,
+  requireJust,
+  resolveApiUrl,
+  resolveApiUrlWithFallback,
+  resolveReachableApiUrl,
+  right,
   selectActiveDirective,
   selectActiveDirectiveId,
   selectActiveNPC,