@forbocai/core 0.6.1 → 0.6.3

package/dist/index.js

@@ -54,6 +54,8 @@ __export(index_exports, {
   getGhostStatusThunk: () => getGhostStatusThunk,
   getSoulListThunk: () => getSoulListThunk,
   ghostSlice: () => ghostSlice,
+  handler_ArweaveDownload: () => handler_ArweaveDownload,
+  handler_ArweaveUpload: () => handler_ArweaveUpload,
   importNpcFromSoulThunk: () => importNpcFromSoulThunk,
   importSoulFromArweaveThunk: () => importSoulFromArweaveThunk,
   initRemoteCortexThunk: () => initRemoteCortexThunk,
@@ -169,6 +171,21 @@ var sdkApi = (0, import_query.createApi)({
       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`,
@@ -310,6 +327,16 @@ var sdkApi = (0, import_query.createApi)({
       invalidatesTags: ["Soul"],
       transformResponse: (response) => response
     }),
+    postSoulExportConfirm: builder.mutation({
+      query: ({ npcId, request, apiUrl, apiKey }) => ({
+        url: `${apiUrl}/npcs/${npcId}/soul/confirm`,
+        method: "POST",
+        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
+        body: request
+      }),
+      invalidatesTags: ["Soul"],
+      transformResponse: (response) => response
+    }),
     getSoulImport: builder.query({
       query: ({ txId, apiUrl, apiKey }) => ({
         url: `${apiUrl}/souls/${txId}`,
@@ -418,6 +445,16 @@ var sdkApi = (0, import_query.createApi)({
       invalidatesTags: ["NPC"],
       transformResponse: (response) => response
     }),
+    postNpcImportConfirm: builder.mutation({
+      query: ({ request, apiUrl, apiKey }) => ({
+        url: `${apiUrl}/npcs/import/confirm`,
+        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 }) => ({
@@ -437,6 +474,25 @@ var sdkApi = (0, import_query.createApi)({
   })
 });
 
+// src/errors.ts
+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: [],
@@ -451,6 +507,7 @@ var validateBridgeThunk = (0, import_toolkit.createAsyncThunk)(
   async ({ action, context, npcId, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
       const url = apiUrl || "https://api.forboc.ai";
+      requireApiKeyGuidance(url, apiKey);
       const data = await dispatch2(sdkApi.endpoints.postBridgeValidate.initiate({
         request: { action, context },
         npcId,
@@ -458,8 +515,8 @@ var validateBridgeThunk = (0, import_toolkit.createAsyncThunk)(
         apiKey
       })).unwrap();
       return data;
-    } catch (e) {
-      return rejectWithValue(e.message || "Bridge validation failed");
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Bridge validation failed"));
     }
   }
 );
@@ -468,9 +525,10 @@ var loadBridgePresetThunk = (0, import_toolkit.createAsyncThunk)(
   async ({ presetName, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
       const url = apiUrl || "https://api.forboc.ai";
+      requireApiKeyGuidance(url, apiKey);
       return await dispatch2(sdkApi.endpoints.postBridgePreset.initiate({ presetName, apiUrl: url, apiKey })).unwrap();
-    } catch (e) {
-      return rejectWithValue(e.message || "Failed to load preset");
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Failed to load preset"));
     }
   }
 );
@@ -479,9 +537,10 @@ var getBridgeRulesThunk = (0, import_toolkit.createAsyncThunk)(
   async ({ apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
       const url = apiUrl || "https://api.forboc.ai";
+      requireApiKeyGuidance(url, apiKey);
       return await dispatch2(sdkApi.endpoints.getBridgeRules.initiate({ apiUrl: url, apiKey })).unwrap();
-    } catch (e) {
-      return rejectWithValue(e.message || "Failed to list bridge rules");
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Failed to list bridge rules"));
     }
   }
 );
@@ -490,9 +549,10 @@ var listRulesetsThunk = (0, import_toolkit.createAsyncThunk)(
   async ({ apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
       const url = apiUrl || "https://api.forboc.ai";
+      requireApiKeyGuidance(url, apiKey);
       return await dispatch2(sdkApi.endpoints.getRulesets.initiate({ apiUrl: url, apiKey })).unwrap();
-    } catch (e) {
-      return rejectWithValue(e.message || "Failed to list rulesets");
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Failed to list rulesets"));
     }
   }
 );
@@ -501,9 +561,10 @@ var listRulePresetsThunk = (0, import_toolkit.createAsyncThunk)(
   async ({ apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
       const url = apiUrl || "https://api.forboc.ai";
+      requireApiKeyGuidance(url, apiKey);
       return await dispatch2(sdkApi.endpoints.getRulePresets.initiate({ apiUrl: url, apiKey })).unwrap();
-    } catch (e) {
-      return rejectWithValue(e.message || "Failed to list rule presets");
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Failed to list rule presets"));
     }
   }
 );
@@ -512,9 +573,10 @@ var registerRulesetThunk = (0, import_toolkit.createAsyncThunk)(
   async ({ ruleset, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
       const url = apiUrl || "https://api.forboc.ai";
+      requireApiKeyGuidance(url, apiKey);
       return await dispatch2(sdkApi.endpoints.postRuleRegister.initiate({ request: ruleset, apiUrl: url, apiKey })).unwrap();
-    } catch (e) {
-      return rejectWithValue(e.message || "Failed to register ruleset");
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Failed to register ruleset"));
     }
   }
 );
@@ -523,9 +585,10 @@ var deleteRulesetThunk = (0, import_toolkit.createAsyncThunk)(
   async ({ rulesetId, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
       const url = apiUrl || "https://api.forboc.ai";
+      requireApiKeyGuidance(url, apiKey);
       return await dispatch2(sdkApi.endpoints.deleteRule.initiate({ rulesetId, apiUrl: url, apiKey })).unwrap();
-    } catch (e) {
-      return rejectWithValue(e.message || "Failed to delete ruleset");
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Failed to delete ruleset"));
     }
   }
 );
@@ -574,6 +637,124 @@ var bridgeSlice_default = bridgeSlice.reducer;
 
 // src/soulSlice.ts
 var import_toolkit2 = require("@reduxjs/toolkit");
+
+// src/handlers/arweave.ts
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var getLocalWalletToken = () => {
+  const maybeEnv = globalThis.process?.env;
+  return maybeEnv?.ARWEAVE_WALLET_JWK ?? null;
+};
+var withTimeout = async (promiseFactory, timeoutMs = 6e4) => {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await promiseFactory(controller.signal);
+  } finally {
+    clearTimeout(timeout);
+  }
+};
+async function handler_ArweaveUpload(instruction, maxRetries = 3) {
+  const headers = {
+    "Content-Type": instruction.auiContentType || "application/json"
+  };
+  const authToken = instruction.auiAuthHeader ?? (getLocalWalletToken() ? `Bearer ${getLocalWalletToken()}` : null);
+  if (authToken) {
+    headers.Authorization = authToken;
+  }
+  let attempt = 0;
+  while (attempt < maxRetries) {
+    attempt += 1;
+    try {
+      const response = await withTimeout(
+        (signal) => fetch(instruction.auiEndpoint, {
+          method: "POST",
+          headers,
+          body: JSON.stringify(instruction.auiPayload),
+          signal
+        })
+      );
+      let responseBody = null;
+      try {
+        responseBody = await response.json();
+      } catch {
+        responseBody = 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;
+      if (!success && attempt < maxRetries) {
+        await sleep(250 * 2 ** (attempt - 1));
+        continue;
+      }
+      return {
+        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);
+      if (attempt < maxRetries) {
+        await sleep(250 * 2 ** (attempt - 1));
+        continue;
+      }
+      return {
+        aurTxId: `ar_tx_failed_${Date.now()}`,
+        aurStatus: 0,
+        aurSuccess: false,
+        aurError: `upload_request_failed:${message}`
+      };
+    }
+  }
+  return {
+    aurTxId: `ar_tx_failed_${Date.now()}`,
+    aurStatus: 0,
+    aurSuccess: false,
+    aurError: "upload_retry_exhausted"
+  };
+}
+async function handler_ArweaveDownload(instruction) {
+  try {
+    const response = await withTimeout(
+      (signal) => fetch(instruction.adiGatewayUrl, {
+        method: "GET",
+        signal
+      })
+    );
+    if (response.status < 200 || response.status >= 300) {
+      return {
+        adrBody: null,
+        adrStatus: response.status,
+        adrSuccess: false,
+        adrError: `download_failed_status_${response.status}`
+      };
+    }
+    try {
+      const body = await response.json();
+      return {
+        adrBody: body,
+        adrStatus: response.status,
+        adrSuccess: true,
+        adrError: null
+      };
+    } catch {
+      return {
+        adrBody: null,
+        adrStatus: response.status,
+        adrSuccess: false,
+        adrError: "download_invalid_json"
+      };
+    }
+  } catch (error) {
+    return {
+      adrBody: null,
+      adrStatus: 0,
+      adrSuccess: false,
+      adrError: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+// src/soulSlice.ts
 var initialState2 = {
   exportStatus: "idle",
   importStatus: "idle",
@@ -584,26 +765,45 @@ 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();
+      requireApiKeyGuidance(url, apiKey);
+      const phase1 = await dispatch2(
+        sdkApi.endpoints.postSoulExport.initiate({
+          npcId,
+          request: { npcIdRef: npcId, persona: npc.persona || "NPC", npcState: npc.state },
+          apiUrl: url,
+          apiKey
+        })
+      ).unwrap();
+      const uploadResult = await handler_ArweaveUpload({
+        ...phase1.se1Instruction,
+        auiAuthHeader: phase1.se1Instruction.auiAuthHeader ?? null
+      });
+      const final = await dispatch2(
+        sdkApi.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"));
     }
   }
 );
@@ -612,10 +812,31 @@ var importSoulFromArweaveThunk = (0, import_toolkit2.createAsyncThunk)(
   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");
+      requireApiKeyGuidance(url, apiKey);
+      const phase1 = await dispatch2(
+        sdkApi.endpoints.postNpcImport.initiate({ request: { txIdRef: txId }, apiUrl: url, apiKey })
+      ).unwrap();
+      const downloadResult = await handler_ArweaveDownload(phase1.si1Instruction);
+      const npc = await dispatch2(
+        sdkApi.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"));
     }
   }
 );
@@ -624,10 +845,11 @@ var getSoulListThunk = (0, import_toolkit2.createAsyncThunk)(
   async ({ limit = 50, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
       const url = apiUrl || "https://api.forboc.ai";
+      requireApiKeyGuidance(url, apiKey);
       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");
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Failed to list souls"));
     }
   }
 );
@@ -636,9 +858,10 @@ var verifySoulThunk = (0, import_toolkit2.createAsyncThunk)(
   async ({ txId, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
       const url = apiUrl || "https://api.forboc.ai";
+      requireApiKeyGuidance(url, apiKey);
       return await dispatch2(sdkApi.endpoints.postSoulVerify.initiate({ txId, apiUrl: url, apiKey })).unwrap();
-    } catch (e) {
-      return rejectWithValue(e.message || "Soul verify failed");
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Soul verify failed"));
     }
   }
 );
@@ -647,13 +870,24 @@ var importNpcFromSoulThunk = (0, import_toolkit2.createAsyncThunk)(
   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");
+      requireApiKeyGuidance(url, apiKey);
+      const phase1 = await dispatch2(
+        sdkApi.endpoints.postNpcImport.initiate({
+          request: { txIdRef: txId },
+          apiUrl: url,
+          apiKey
+        })
+      ).unwrap();
+      const downloadResult = await handler_ArweaveDownload(phase1.si1Instruction);
+      return await dispatch2(
+        sdkApi.endpoints.postNpcImportConfirm.initiate({
+          request: { sicTxId: txId, sicDownloadResult: downloadResult },
+          apiUrl: url,
+          apiKey
+        })
+      ).unwrap();
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "NPC import from soul failed"));
     }
   }
 );
@@ -712,6 +946,7 @@ var startGhostThunk = (0, import_toolkit3.createAsyncThunk)(
   async (config, { dispatch: dispatch2, rejectWithValue }) => {
     try {
       const apiUrl = config.apiUrl || "https://api.forboc.ai";
+      requireApiKeyGuidance(apiUrl, config.apiKey);
       const data = await dispatch2(sdkApi.endpoints.postGhostRun.initiate({
         request: { testSuite: config.testSuite, duration: config.duration ?? 300 },
         apiUrl,
@@ -721,8 +956,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"));
     }
   }
 );
@@ -734,6 +969,7 @@ var getGhostStatusThunk = (0, import_toolkit3.createAsyncThunk)(
       const targetSession = sessionId || state.activeSessionId;
       if (!targetSession) throw new Error("No active Ghost session");
       const url = apiUrl || "https://api.forboc.ai";
+      requireApiKeyGuidance(url, apiKey);
       const data = await dispatch2(sdkApi.endpoints.getGhostStatus.initiate({ sessionId: targetSession, apiUrl: url, apiKey })).unwrap();
       return {
         sessionId: data.ghostSessionId,
@@ -743,8 +979,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"));
     }
   }
 );
@@ -756,6 +992,7 @@ var getGhostResultsThunk = (0, import_toolkit3.createAsyncThunk)(
       const targetSession = sessionId || state.activeSessionId;
       if (!targetSession) throw new Error("No active Ghost session");
       const url = apiUrl || "https://api.forboc.ai";
+      requireApiKeyGuidance(url, apiKey);
       const data = await dispatch2(sdkApi.endpoints.getGhostResults.initiate({ sessionId: targetSession, apiUrl: url, apiKey })).unwrap();
       return {
         sessionId: data.resultsSessionId,
@@ -774,8 +1011,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"));
     }
   }
 );
@@ -787,14 +1024,15 @@ var stopGhostThunk = (0, import_toolkit3.createAsyncThunk)(
       const targetSession = sessionId || state.activeSessionId;
       if (!targetSession) throw new Error("No active Ghost session");
       const url = apiUrl || "https://api.forboc.ai";
+      requireApiKeyGuidance(url, apiKey);
       const data = await dispatch2(sdkApi.endpoints.postGhostStop.initiate({ sessionId: targetSession, apiUrl: url, apiKey })).unwrap();
       return {
         stopped: data.stopped,
         status: data.stopStatus,
         sessionId: data.stopSessionId
       };
-    } catch (e) {
-      return rejectWithValue(e.message || "Failed to stop ghost session");
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Failed to stop ghost session"));
     }
   }
 );
@@ -803,6 +1041,7 @@ var getGhostHistoryThunk = (0, import_toolkit3.createAsyncThunk)(
   async ({ limit = 10, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
       const url = apiUrl || "https://api.forboc.ai";
+      requireApiKeyGuidance(url, apiKey);
       const data = await dispatch2(sdkApi.endpoints.getGhostHistory.initiate({ limit, apiUrl: url, apiKey })).unwrap();
       return (data.sessions || []).map((s) => ({
         sessionId: s.sessionId,
@@ -812,8 +1051,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"));
     }
   }
 );
@@ -848,7 +1087,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";
       }
@@ -863,7 +1102,7 @@ var { clearGhostSession } = ghostSlice.actions;
 var ghostSlice_default = ghostSlice.reducer;
 
 // src/utils/sdkVersion.ts
-var SDK_VERSION = "0.6.0";
+var SDK_VERSION = "0.6.1";
 
 // src/utils/generateNPCId.ts
 var generateNPCId = () => `ag_${Date.now().toString(36)}`;
@@ -944,7 +1183,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;
     },
@@ -959,7 +1199,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) => {
@@ -1029,6 +1271,7 @@ var initRemoteCortexThunk = (0, import_toolkit5.createAsyncThunk)(
   async ({ model = "api-integrated", authKey, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
       const url = apiUrl || "https://api.forboc.ai";
+      requireApiKeyGuidance(url, apiKey);
       const data = await dispatch2(sdkApi.endpoints.postCortexInit.initiate({
         request: { requestedModel: model, authKey },
         apiUrl: url,
@@ -1040,8 +1283,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"));
     }
   }
 );
@@ -1050,9 +1293,10 @@ var listCortexModelsThunk = (0, import_toolkit5.createAsyncThunk)(
   async ({ apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
       const url = apiUrl || "https://api.forboc.ai";
+      requireApiKeyGuidance(url, apiKey);
       return await dispatch2(sdkApi.endpoints.getCortexModels.initiate({ apiUrl: url, apiKey })).unwrap();
-    } catch (e) {
-      return rejectWithValue(e.message || "Failed to list cortex models");
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Failed to list cortex models"));
     }
   }
 );
@@ -1060,6 +1304,7 @@ var completeRemoteThunk = (0, import_toolkit5.createAsyncThunk)(
   "cortex/completeRemote",
   async ({ cortexId, prompt, options, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
+      requireApiKeyGuidance(apiUrl, apiKey);
       const data = await dispatch2(sdkApi.endpoints.postCortexComplete.initiate({
         cortexId,
         prompt,
@@ -1068,8 +1313,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"));
     }
   }
 );
@@ -1304,6 +1549,13 @@ var dispatch = store.dispatch;
 
 // src/thunks.ts
 var import_toolkit10 = require("@reduxjs/toolkit");
+var extractThunkErrorMessage2 = (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, rejectWithValue }) => {
@@ -1327,61 +1579,111 @@ var processNPC = (0, import_toolkit10.createAsyncThunk)(
     const directiveId = `${npcId}:${Date.now()}`;
     dispatch2(directiveRunStarted({ id: directiveId, npcId, observation: text }));
     try {
-      const directiveResult = await dispatch2(
-        sdkApi.endpoints.postDirective.initiate({ npcId, request: { observation: text, npcState: currentState, context }, apiUrl, apiKey })
-      ).unwrap();
-      dispatch2(directiveReceived({ id: directiveId, response: directiveResult }));
-      if (directiveResult.memoryRecall && !memory) {
-        return rejectWithValue("API requested memory recall, but no memory engine is configured");
-      }
-      const recalledMemories = memory && directiveResult.memoryRecall ? (await memory.recall(
-        directiveResult.memoryRecall.query,
-        directiveResult.memoryRecall.limit,
-        directiveResult.memoryRecall.threshold
-      )).map((m) => ({ text: m.text, type: m.type, importance: m.importance })) : [];
-      const contextResult = await dispatch2(
-        sdkApi.endpoints.postContext.initiate({ npcId, request: { memories: recalledMemories, observation: text, npcState: currentState, persona }, apiUrl, apiKey })
-      ).unwrap();
-      dispatch2(contextComposed({ id: directiveId, prompt: contextResult.prompt, constraints: contextResult.constraints }));
-      const generatedText = await cortex.complete(contextResult.prompt, {
-        maxTokens: contextResult.constraints.maxTokens,
-        temperature: contextResult.constraints.temperature,
-        stop: contextResult.constraints.stop
-      });
-      const verdictResult = await dispatch2(
-        sdkApi.endpoints.postVerdict.initiate({ npcId, request: { generatedOutput: generatedText, observation: text, npcState: currentState }, apiUrl, apiKey })
-      ).unwrap();
-      dispatch2(verdictValidated({ id: directiveId, verdict: verdictResult }));
-      if (!verdictResult.valid) {
-        dispatch2(blockAction({ id: npcId, reason: verdictResult.dialogue || "Validation Failed" }));
-        return {
-          dialogue: verdictResult.dialogue,
-          action: verdictResult.action,
-          thought: verdictResult.dialogue
-        };
-      }
-      if (verdictResult.memoryStore?.length && !memory) {
-        return rejectWithValue("API returned memoryStore instructions, but no memory engine is configured");
-      }
-      if (memory && verdictResult.memoryStore) {
-        for (const inst of verdictResult.memoryStore) {
-          await memory.store(inst.text, inst.type, inst.importance);
+      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;
         }
-      }
-      if (verdictResult.stateDelta) {
-        dispatch2(updateNPCState({ id: npcId, delta: verdictResult.stateDelta }));
-      }
-      const action = verdictResult.action;
-      dispatch2(setLastAction({ id: npcId, action }));
-      dispatch2(addToHistory({ id: npcId, role: "user", content: text }));
-      dispatch2(addToHistory({ id: npcId, role: "assistant", content: verdictResult.dialogue }));
-      return {
-        dialogue: verdictResult.dialogue,
-        action,
-        thought: verdictResult.dialogue
+        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 = e?.message || e?.data?.message || "Protocol processing failed";
+      const message = extractThunkErrorMessage2(e);
       dispatch2(directiveRunFailed({ id: directiveId, error: String(message) }));
       return rejectWithValue(String(message));
     }
@@ -1502,6 +1804,8 @@ var clearMemoryRemoteThunk = (0, import_toolkit10.createAsyncThunk)(
   getGhostStatusThunk,
   getSoulListThunk,
   ghostSlice,
+  handler_ArweaveDownload,
+  handler_ArweaveUpload,
   importNpcFromSoulThunk,
   importSoulFromArweaveThunk,
   initRemoteCortexThunk,