@zeniai/client-epic-state 5.2.4 → 5.2.6

package/lib/esm/view/aiCfoView/aiCfoViewReducer.js

@@ -48,8 +48,81 @@ export const initialAiCfoViewState = {
     responseStateByChatSessionId: {},
     stopSubmitStateByChatSessionId: {},
     suggestedQuestionsByPageContext: {},
-    skills: { fetchState: 'Not-Started', error: undefined, skills: [] },
+    skillDetail: {
+        fetchState: 'Not-Started',
+        error: undefined,
+        detail: undefined,
+        macroId: undefined,
+    },
+    skillMutation: {
+        fetchState: 'Not-Started',
+        error: undefined,
+        savedMacroId: undefined,
+    },
+    skillVersionBody: {
+        fetchState: 'Not-Started',
+        error: undefined,
+        instructions: undefined,
+        macroId: undefined,
+        version: undefined,
+    },
+    skillVersions: {
+        fetchState: 'Not-Started',
+        error: undefined,
+        versions: [],
+        macroId: undefined,
+    },
+    skills: {
+        fetchState: 'Not-Started',
+        error: undefined,
+        deletedMacroIds: [],
+        skills: [],
+        skillsEnabled: false,
+        canPublish: false,
+    },
 };
+/**
+ * Forget the skill that was open — prompt AND history together.
+ *
+ * Both, always. They are two slices describing one selection, so clearing only the
+ * prompt leaves `skillVersions.macroId` matching: an in-flight history response then
+ * passes its own stale-response guard and renders the previous skill's versions under
+ * whatever the user opened next.
+ */
+function clearOpenSkillState(draft) {
+    draft.skillDetail = {
+        fetchState: 'Not-Started',
+        error: undefined,
+        detail: undefined,
+        macroId: undefined,
+    };
+    draft.skillVersions = {
+        fetchState: 'Not-Started',
+        error: undefined,
+        versions: [],
+        macroId: undefined,
+    };
+    // Part of the same selection: a pinned body left behind would seed a restore form for
+    // a skill the user has left.
+    draft.skillVersionBody = {
+        fetchState: 'Not-Started',
+        error: undefined,
+        instructions: undefined,
+        macroId: undefined,
+        version: undefined,
+    };
+}
+/**
+ * Take the Skills browser down and drop the prompt it had open.
+ *
+ * Both halves together, always. Closing without clearing leaves the next open landing on
+ * the previous skill instead of the list, and leaves a `macroId` that makes an in-flight
+ * detail response look current to the stale-response guard.
+ */
+function closeSkillsBrowserState(draft) {
+    draft.uiState.isSkillsBrowserOpen = false;
+    clearOpenSkillState(draft);
+}
 const aiCfoView = createSlice({
     name: 'aiCfoView',
     initialState: initialAiCfoViewState,
@@ -57,6 +130,16 @@ const aiCfoView = createSlice({
         submitQuestion: {
             reducer(draft, action) {
                 const { sessionId } = action.payload;
+                // A turn is being sent, so the chat body has to be what the user sees. Doing this
+                // here rather than at each call site is deliberate: the composer, the sample
+                // chips, Run, and the `/` menu all submit, and every one of them was a separate
+                // chance to forget and leave the answer hidden behind the browser.
+                //
+                // Guarded so a submit with the browser already closed — i.e. almost every submit
+                // — does not produce a new `uiState` for every subscriber to re-render on.
+                if (draft.uiState.isSkillsBrowserOpen === true) {
+                    closeSkillsBrowserState(draft);
+                }
                 draft.responseStateByChatSessionId[sessionId] = {
                     thought: { fetchState: 'In-Progress', error: undefined },
                     analysis: { fetchState: 'In-Progress', error: undefined },
@@ -183,6 +266,13 @@ const aiCfoView = createSlice({
         setSession(draft, action) {
             draft.uiState.currentChatSessionId = action.payload.sessionId;
             draft.uiState.agentId = action.payload.agentId;
+            // Picking a session means wanting to see that chat, so the browser cannot stay over
+            // it. In the reducer because there are six dispatch sites across three separate
+            // rails, and covering them one at a time missed half of them.
+            if (action.payload.isRestore !== true &&
+                draft.uiState.isSkillsBrowserOpen === true) {
+                closeSkillsBrowserState(draft);
+            }
             mirrorCurrentSessionToPageKeyMapIfActive(draft);
         },
         createSession: {
@@ -202,6 +292,12 @@ const aiCfoView = createSlice({
             draft.uiState.agentId = agentId;
             draft.createSessionState.fetchState = 'Completed';
             draft.createSessionState.error = undefined;
+            // Same invariant as submitQuestion and initializeNewSessionState: a new chat exists
+            // and is now current, so the browser cannot stay over it. This is the fifth entry
+            // point to that rule — the others are submit, new-session, New Chat and setSession.
+            if (draft.uiState.isSkillsBrowserOpen === true) {
+                closeSkillsBrowserState(draft);
+            }
             draft.uiState.currentChatSessionId = sessionId;
             draft.uiState.lastContextMessage = contextMessage;
             draft.uiState.lastContextStatus = contextStatus;
@@ -243,6 +339,10 @@ const aiCfoView = createSlice({
         },
         initializeNewSessionState(draft, action) {
             const { agentId, sessionId } = action.payload;
+            // Same invariant as submitQuestion — this is the new-session half of submitting.
+            if (draft.uiState.isSkillsBrowserOpen === true) {
+                closeSkillsBrowserState(draft);
+            }
             draft.uiState.currentChatSessionId = sessionId;
             draft.uiState.agentId = agentId;
             draft.uiState.chatHistoryNextPageToken[sessionId] = {
@@ -363,6 +463,10 @@ const aiCfoView = createSlice({
             };
             draft.allChatSessionIds = draft.allChatSessionIds.filter((id) => id !== chatSessionId);
             if (draft.uiState.currentChatSessionId === chatSessionId) {
+                // Deliberately does NOT close the Skills browser, unlike the other writers of
+                // this field. Deleting a chat from the history list is housekeeping: if the
+                // browser is open the user is not looking at that chat, and closing it would
+                // yank them out of what they were doing to reveal an empty chat area.
                 draft.uiState.currentChatSessionId = undefined;
                 draft.uiState.agentId = undefined;
             }
@@ -415,6 +519,10 @@ const aiCfoView = createSlice({
             },
         },
         clearCurrentSessionId(draft) {
+            // New Chat: the empty composer is the point, so the browser cannot stay over it.
+            if (draft.uiState.isSkillsBrowserOpen === true) {
+                closeSkillsBrowserState(draft);
+            }
             draft.uiState.currentChatSessionId = undefined;
             const key = draft.uiState.aiCfoSidePanelHostPageKey;
             if (key != null) {
@@ -431,8 +539,24 @@ const aiCfoView = createSlice({
                 draft.uiState.chatSessionIdByPageKey[prevKey] = curId;
             }
             draft.uiState.aiCfoSidePanelHostPageKey = newAiCfoSidePanelHostPageKey;
-            draft.uiState.currentChatSessionId =
-                nextCurrentChatSessionId != null ? nextCurrentChatSessionId : undefined;
+            const nextId = nextCurrentChatSessionId != null ? nextCurrentChatSessionId : undefined;
+            // The sixth entry point to the same invariant as submitQuestion,
+            // initializeNewSessionState, clearCurrentSessionId, setSession and
+            // createSessionSuccess: a different chat is now visible, so the browser cannot stay
+            // over it. Missing here, this path swapped the session underneath an open browser
+            // and left its macroId looking current to the stale-response guards.
+            //
+            // Only when the session actually CHANGES, and only when there WAS one. A host page
+            // resolving back to the same chat has not changed what is on screen. And
+            // `undefined` becoming a saved id is a hydrate, not a navigation — the same
+            // settle/restore race `setSession` exempts via `isRestore`: opening Skills on a
+            // host page whose chat has not resolved yet would otherwise close the browser
+            // under the user the moment the sessions list arrives.
+            const hadASession = draft.uiState.currentChatSessionId != null;
+            if (hadASession && nextId !== draft.uiState.currentChatSessionId) {
+                closeSkillsBrowserState(draft);
+            }
+            draft.uiState.currentChatSessionId = nextId;
             draft.uiState.currentInput = '';
             mirrorCurrentSessionToPageKeyMapIfActive(draft);
         },
@@ -477,28 +601,306 @@ const aiCfoView = createSlice({
             };
         },
         fetchSkills(draft) {
-            // Optional-chain: persisted/rehydrated state from before this slice existed
-            // may have no `skills`, so don't assume draft.skills is set.
+            // Read straight off `draft.skills` — no optional chain. This store is never
+            // persisted or rehydrated (no redux-persist anywhere in the repo, and no
+            // `preloadedState` in any consumer), and `initialAiCfoViewState` gives every skills
+            // slice a concrete value, so an undefined slice is unreachable here rather than
+            // merely unlikely. An earlier version of this comment claimed the opposite and
+            // justified a guard by a mechanism that does not exist — which then got applied to
+            // some accesses and not others, so the file read as if the slice were sometimes
+            // missing and sometimes not. The one guard that IS meaningful lives in the
+            // selectors, where `state.aiCfoViewState` may genuinely be absent for a host that
+            // composes a partial root reducer; that is a boundary, and this is not.
             draft.skills = {
                 fetchState: 'In-Progress',
                 error: undefined,
-                skills: draft.skills?.skills ?? [],
+                skills: draft.skills.skills,
+                skillsEnabled: draft.skills.skillsEnabled,
+                // Carried for the same reason as skillsEnabled: a refetch in flight is not a
+                // reason to hide the publish control the user was just looking at.
+                canPublish: draft.skills.canPublish,
+                // Carried, not cleared: the response this is about to fetch may still contain a
+                // skill deleted moments ago, which is the whole reason the list is kept.
+                deletedMacroIds: draft.skills.deletedMacroIds,
             };
         },
         fetchSkillsSuccess(draft, action) {
+            // A list response can predate a delete — a save emits fetchSkills, and a delete can
+            // land while that is still outstanding — so replacing the array wholesale would put
+            // the deleted row back and read as the delete having failed.
             draft.skills = {
                 fetchState: 'Completed',
                 error: undefined,
-                skills: action.payload.skills,
+                skills: action.payload.skills.filter((skill) => !draft.skills.deletedMacroIds.includes(skill.macroId)),
+                skillsEnabled: action.payload.skillsEnabled,
+                canPublish: action.payload.canPublish,
+                // Applied ONCE, then forgotten — the tombstone covers a race window, not a
+                // permanent state.
+                //
+                // The previous rule (keep it until a response omits that skill) was wrong in the
+                // case it was written for: nothing refetches after a delete, and a create emits
+                // fetchSkills whose response DOES contain the id, so the tombstone was kept and
+                // reapplied forever. A skill recreated under the same id stayed invisible with no
+                // way to clear it.
+                deletedMacroIds: [],
             };
         },
         fetchSkillsFailure(draft, action) {
             draft.skills = {
                 fetchState: 'Error',
                 error: action.payload,
-                skills: draft.skills?.skills ?? [],
+                skills: draft.skills.skills,
+                // Kept, not reset: a failed refresh is not evidence the feature was turned
+                // off, and dropping it to false would make the Skills entry vanish on any
+                // transient error.
+                skillsEnabled: draft.skills.skillsEnabled,
+                // Same reasoning again: a transient error must not revoke a privilege the server
+                // already granted, or the control flickers away on every failed refresh.
+                canPublish: draft.skills.canPublish,
+                // Same reasoning: a failed refresh is not confirmation the delete was undone.
+                deletedMacroIds: draft.skills.deletedMacroIds,
+            };
+        },
+        fetchSkillDetail(draft, action) {
+            // Opening a skill IS the selection change, so forget the previous one whole —
+            // history included. Resetting only the prompt left `skillVersions.macroId` pointing
+            // at the skill just navigated away from, so a history response still in flight for
+            // it passed its own guard and rendered under the new title. Close, back and delete
+            // all go through the same helper for the same reason.
+            clearOpenSkillState(draft);
+            draft.skillDetail = {
+                fetchState: 'In-Progress',
+                error: undefined,
+                // Cleared rather than kept: holding the previous skill's prompt while a new
+                // one loads would show the wrong instructions under the right title.
+                detail: undefined,
+                macroId: action.payload.macroId,
+            };
+        },
+        fetchSkillDetailSuccess(draft, action) {
+            // Ignore a response for a skill the user has already navigated away from.
+            if (draft.skillDetail.macroId !== action.payload.macroId) {
+                return;
+            }
+            draft.skillDetail = {
+                fetchState: 'Completed',
+                error: undefined,
+                detail: action.payload.detail,
+                macroId: action.payload.macroId,
+            };
+        },
+        fetchSkillDetailFailure(draft, action) {
+            if (draft.skillDetail.macroId !== action.payload.macroId) {
+                return;
+            }
+            draft.skillDetail = {
+                fetchState: 'Error',
+                error: action.payload.error,
+                detail: undefined,
+                macroId: action.payload.macroId,
             };
         },
+        clearSkillDetail(draft) {
+            // Back to the list. History belongs to the detail view, so it goes too.
+            clearOpenSkillState(draft);
+        },
+        fetchSkillVersions: {
+            reducer(draft, action) {
+                draft.skillVersions = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                    // Cleared, not kept: showing the previous skill's history under a new title
+                    // is worse than showing none while this loads.
+                    versions: [],
+                    macroId: action.payload.macroId,
+                };
+            },
+            prepare(payload) {
+                return { payload };
+            },
+        },
+        fetchSkillVersionsSuccess(draft, action) {
+            // Same stale-response guard as skillDetail: a switchMap cancels the request but
+            // cannot un-dispatch one already in flight.
+            if (draft.skillVersions.macroId !== action.payload.macroId) {
+                return;
+            }
+            draft.skillVersions.fetchState = 'Completed';
+            draft.skillVersions.error = undefined;
+            draft.skillVersions.versions = action.payload.versions;
+        },
+        fetchSkillVersionsFailure(draft, action) {
+            if (draft.skillVersions.macroId !== action.payload.macroId) {
+                return;
+            }
+            draft.skillVersions.fetchState = 'Error';
+            draft.skillVersions.error = action.payload.error;
+        },
+        fetchSkillVersionBody: {
+            reducer(draft, action) {
+                draft.skillVersionBody = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                    // Cleared: seeding a restore form from the PREVIOUS version's body is the same
+                    // class of mistake as showing one skill's prompt under another's title.
+                    instructions: undefined,
+                    macroId: action.payload.macroId,
+                    version: action.payload.version,
+                };
+            },
+            prepare(payload) {
+                return { payload };
+            },
+        },
+        fetchSkillVersionBodySuccess(draft, action) {
+            // Both parts of the key: a user can jump between versions of the same skill, so
+            // macroId alone would let an earlier version's body land on a later request.
+            if (draft.skillVersionBody.macroId !== action.payload.macroId ||
+                draft.skillVersionBody.version !== action.payload.version) {
+                return;
+            }
+            draft.skillVersionBody.fetchState = 'Completed';
+            draft.skillVersionBody.error = undefined;
+            draft.skillVersionBody.instructions = action.payload.instructions;
+        },
+        fetchSkillVersionBodyFailure(draft, action) {
+            if (draft.skillVersionBody.macroId !== action.payload.macroId ||
+                draft.skillVersionBody.version !== action.payload.version) {
+                return;
+            }
+            draft.skillVersionBody.fetchState = 'Error';
+            draft.skillVersionBody.error = action.payload.error;
+        },
+        saveSkill: {
+            reducer(draft) {
+                draft.skillMutation = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                    savedMacroId: undefined,
+                };
+            },
+            prepare(payload) {
+                return { payload };
+            },
+        },
+        saveSkillSuccess(draft, action) {
+            draft.skillMutation.fetchState = 'Completed';
+            draft.skillMutation.error = undefined;
+            draft.skillMutation.savedMacroId = action.payload.macroId;
+            // ONLY when the saved skill is still the one on screen. The save is a mergeMap —
+            // deliberately not cancellable, because cancelling a write only hides its outcome —
+            // so it can land after the user opened another skill, went back to the list, closed
+            // the browser, or deleted it. Writing unconditionally would drop one skill's prompt
+            // on top of another's, which is precisely what the fetch guards exist to prevent.
+            //
+            // A create lands here with nothing open, and is deliberately NOT force-opened:
+            // `savedMacroId` is the signal for "what did I just create", and the caller decides
+            // whether to open it.
+            if (draft.skillDetail.macroId !== action.payload.macroId) {
+                return;
+            }
+            // The save response IS a detail read, so adopt it. Discarding it left an editor
+            // sitting on the same skill showing the prompt and card it had BEFORE the save —
+            // the user's own change missing from the thing they just saved.
+            draft.skillDetail = {
+                fetchState: 'Completed',
+                error: undefined,
+                detail: action.payload.detail,
+                macroId: action.payload.macroId,
+            };
+            // History is now a version behind; the epic refetches it.
+            draft.skillVersions = {
+                fetchState: 'Not-Started',
+                error: undefined,
+                versions: [],
+                macroId: undefined,
+            };
+        },
+        saveSkillFailure(draft, action) {
+            draft.skillMutation.fetchState = 'Error';
+            draft.skillMutation.error = action.payload;
+        },
+        setSkillVisibility: {
+            reducer(draft) {
+                // Shares skillMutation with save and delete. One in-flight write at a time is the
+                // existing contract here, and publishing is a write like any other.
+                draft.skillMutation = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                    savedMacroId: undefined,
+                };
+            },
+            prepare(payload) {
+                return { payload };
+            },
+        },
+        setSkillVisibilitySuccess(draft, action) {
+            draft.skillMutation.fetchState = 'Completed';
+            draft.skillMutation.error = undefined;
+            draft.skillMutation.savedMacroId = action.payload.macroId;
+            // Same staleness guard as saveSkillSuccess, for the same reason: this is a mergeMap
+            // write, so it can land after the user opened another skill.
+            if (draft.skillDetail.macroId !== action.payload.macroId) {
+                return;
+            }
+            draft.skillDetail = {
+                fetchState: 'Completed',
+                error: undefined,
+                detail: action.payload.detail,
+                macroId: action.payload.macroId,
+            };
+            // Deliberately NOT clearing skillVersions, unlike saveSkillSuccess. No version was
+            // created, so the history the user is looking at is still correct — refetching it
+            // would flash a loading state for a list that did not change.
+        },
+        setSkillVisibilityFailure(draft, action) {
+            draft.skillMutation.fetchState = 'Error';
+            draft.skillMutation.error = action.payload;
+        },
+        deleteSkill: {
+            reducer(draft) {
+                draft.skillMutation = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                    savedMacroId: undefined,
+                };
+            },
+            prepare(payload) {
+                return { payload };
+            },
+        },
+        deleteSkillSuccess(draft, action) {
+            draft.skillMutation.fetchState = 'Completed';
+            draft.skillMutation.error = undefined;
+            // Drop it from the list immediately rather than waiting for a refetch: the row
+            // the user just deleted staying on screen reads as the delete having failed.
+            draft.skills.skills = draft.skills.skills.filter((skill) => skill.macroId !== action.payload.macroId);
+            if (!draft.skills.deletedMacroIds.includes(action.payload.macroId)) {
+                draft.skills.deletedMacroIds.push(action.payload.macroId);
+            }
+            if (draft.skillDetail.macroId === action.payload.macroId) {
+                clearOpenSkillState(draft);
+            }
+        },
+        deleteSkillFailure(draft, action) {
+            draft.skillMutation.fetchState = 'Error';
+            draft.skillMutation.error = action.payload;
+        },
+        clearSkillMutation(draft) {
+            draft.skillMutation = {
+                fetchState: 'Not-Started',
+                error: undefined,
+                savedMacroId: undefined,
+            };
+        },
+        openSkillsBrowser(draft) {
+            draft.uiState.isSkillsBrowserOpen = true;
+        },
+        closeSkillsBrowser(draft) {
+            // Unguarded, unlike the implicit closes: an explicit close should clear a lingering
+            // detail even if the flag is already false.
+            closeSkillsBrowserState(draft);
+        },
         updateCotCollapsedState(draft, action) {
             const { isCollapsed, questionAnswerId } = action.payload;
             draft.uiState.cotCollapsedByQuestionAnswerId[questionAnswerId] =
@@ -511,5 +913,5 @@ const aiCfoView = createSlice({
         });
     },
 });
-export const { submitQuestion, submitQuestionSuccess, submitQuestionFailure, updateResponseState, updateAiCfoViewScrollPosition, updateCurrentInput, submitFeedback, submitFeedbackSuccess, submitFeedbackFailure, setSession, createSession, createSessionSuccess, createSessionFailure, createSessionAndSubmit, initializeNewSessionState, createSessionAndSubmitSuccess, createSessionAndSubmitFailure, fetchChatSessionsForUser, fetchChatSessionsForUserSuccess, fetchChatSessionsForUserFailure, fetchChatHistory, fetchChatHistorySuccess, fetchChatHistoryFailure, clearCurrentSessionId, clearLastContextMessage, stopSubmit, stopSubmitSuccess, stopSubmitFailure, stopSubmitQuestion, stopSubmitQuestionSuccess, stopSubmitQuestionFailure, acceptMasterTOS, acceptMasterTOSSuccess, acceptMasterTOSFailure, deleteChatSession, deleteChatSessionSuccess, deleteChatSessionFailure, clearDeleteChatSessionStatus, updateCotCollapsedState, fetchSuggestedQuestions, fetchSuggestedQuestionsSuccess, fetchSuggestedQuestionsFailure, fetchSkills, fetchSkillsSuccess, fetchSkillsFailure, applyAiCfoSidePanelHostPageTransition, clearAiCfoSidePanelHostPageContext, } = aiCfoView.actions;
+export const { submitQuestion, submitQuestionSuccess, submitQuestionFailure, updateResponseState, updateAiCfoViewScrollPosition, updateCurrentInput, submitFeedback, submitFeedbackSuccess, submitFeedbackFailure, setSession, createSession, createSessionSuccess, createSessionFailure, createSessionAndSubmit, initializeNewSessionState, createSessionAndSubmitSuccess, createSessionAndSubmitFailure, fetchChatSessionsForUser, fetchChatSessionsForUserSuccess, fetchChatSessionsForUserFailure, fetchChatHistory, fetchChatHistorySuccess, fetchChatHistoryFailure, clearCurrentSessionId, clearLastContextMessage, stopSubmit, stopSubmitSuccess, stopSubmitFailure, stopSubmitQuestion, stopSubmitQuestionSuccess, stopSubmitQuestionFailure, acceptMasterTOS, acceptMasterTOSSuccess, acceptMasterTOSFailure, deleteChatSession, deleteChatSessionSuccess, deleteChatSessionFailure, clearDeleteChatSessionStatus, updateCotCollapsedState, fetchSuggestedQuestions, fetchSuggestedQuestionsSuccess, fetchSuggestedQuestionsFailure, fetchSkills, fetchSkillsSuccess, fetchSkillsFailure, fetchSkillDetail, fetchSkillDetailSuccess, fetchSkillDetailFailure, clearSkillDetail, clearSkillMutation, deleteSkill, deleteSkillSuccess, deleteSkillFailure, fetchSkillVersionBody, fetchSkillVersionBodySuccess, fetchSkillVersionBodyFailure, fetchSkillVersions, fetchSkillVersionsSuccess, fetchSkillVersionsFailure, saveSkill, saveSkillSuccess, saveSkillFailure, setSkillVisibility, setSkillVisibilitySuccess, setSkillVisibilityFailure, openSkillsBrowser, closeSkillsBrowser, applyAiCfoSidePanelHostPageTransition, clearAiCfoSidePanelHostPageContext, } = aiCfoView.actions;
 export default aiCfoView.reducer;

package/lib/esm/view/aiCfoView/aiCfoViewSelector.js

@@ -29,7 +29,56 @@ const EMPTY_SKILLS_STATE = {
     fetchState: 'Not-Started',
     error: undefined,
     skills: [],
+    // false, so the Skills entry stays hidden until the server confirms the feature
+    // is on. Defaulting true would flash a menu at tenants who never get one.
+    skillsEnabled: false,
+    // false, for the same reason as skillsEnabled: withhold the publish control until the
+    // server says this user may use it.
+    canPublish: false,
+    deletedMacroIds: [],
+};
+const EMPTY_SKILL_DETAIL_STATE = {
+    fetchState: 'Not-Started',
+    error: undefined,
+    detail: undefined,
+    macroId: undefined,
+};
+// Same stable-fallback reason as the two above: a selector that built a fresh object
+// each call would re-render every subscriber on every unrelated state change.
+const EMPTY_SKILL_VERSIONS_STATE = {
+    fetchState: 'Not-Started',
+    error: undefined,
+    versions: [],
+    macroId: undefined,
+};
+const EMPTY_SKILL_VERSION_BODY_STATE = {
+    fetchState: 'Not-Started',
+    error: undefined,
+    instructions: undefined,
+    macroId: undefined,
+    version: undefined,
+};
+const EMPTY_SKILL_MUTATION_STATE = {
+    fetchState: 'Not-Started',
+    error: undefined,
+    savedMacroId: undefined,
 };
 export function getSkills(state) {
     return state.aiCfoViewState?.skills ?? EMPTY_SKILLS_STATE;
 }
+export function getSkillDetail(state) {
+    return state.aiCfoViewState?.skillDetail ?? EMPTY_SKILL_DETAIL_STATE;
+}
+export function getSkillVersions(state) {
+    return state.aiCfoViewState?.skillVersions ?? EMPTY_SKILL_VERSIONS_STATE;
+}
+export function getSkillVersionBody(state) {
+    return (state.aiCfoViewState?.skillVersionBody ?? EMPTY_SKILL_VERSION_BODY_STATE);
+}
+export function getSkillMutation(state) {
+    return state.aiCfoViewState?.skillMutation ?? EMPTY_SKILL_MUTATION_STATE;
+}
+/** True only when the server says the feature is on for this tenant. */
+export function getSkillsEnabled(state) {
+    return getSkills(state).skillsEnabled;
+}

package/lib/esm/view/aiCfoView/epics/deleteSkillEpic.js

@@ -0,0 +1,23 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessStatus } from '../../../responsePayload';
+import { deleteSkill, deleteSkillFailure, deleteSkillSuccess, } from '../aiCfoViewReducer';
+/** DELETE /1.0/skills/{macroId} — soft-deletes every version, frees the name. */
+export const deleteSkillEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(deleteSkill.match), 
+// mergeMap for the same reason as the save: cancelling a delete does not un-delete
+// it, and two deletes are for different skills anyway.
+mergeMap((action) => {
+    const { macroId } = action.payload;
+    const url = `${zeniAPI.apiEndPoints.aiCfoMicroServiceBaseUrl}/1.0/skills/${encodeURIComponent(macroId)}`;
+    return zeniAPI.deleteAndGetJSON(url).pipe(mergeMap((response) => {
+        // isSuccessStatus, NOT isSuccessResponse: the latter also requires a non-null
+        // `data`, and a successful DELETE here is a 204 with no body. Using it reported
+        // every completed delete as a failure — the row stayed on screen and a retry
+        // 404'd on a skill that was already gone. deleteChatSessionEpic uses the status
+        // check for the same reason.
+        if (isSuccessStatus(response)) {
+            return of(deleteSkillSuccess({ macroId }));
+        }
+        return of(deleteSkillFailure(response.status));
+    }), catchError((error) => of(deleteSkillFailure(createZeniAPIStatus('Unexpected Error', 'Delete skill REST API call failed', error instanceof Error ? { message: error.message } : undefined)))));
+}));

package/lib/esm/view/aiCfoView/epics/fetchSkillDetailEpic.js

@@ -0,0 +1,35 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessResponse } from '../../../responsePayload';
+import { fetchSkillDetail, fetchSkillDetailFailure, fetchSkillDetailSuccess, } from '../aiCfoViewReducer';
+import { isSkillDetailPayload, toSkillDetail } from './toSkillDetail';
+// Deliberately minimal: the browser already holds the full Skill from the list, and
+// this response's `skill` block exists so a deep link can open a detail view without
+// the list ever having been fetched.
+/** GET {aiCfoMicroServiceBaseUrl}/1.0/skills/{macroId} — one skill's prompt + card. */
+export const fetchSkillDetailEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(fetchSkillDetail.match), 
+// switchMap: clicking through the list fires one of these per skill, and only the
+// one the user is currently looking at matters. The reducer also drops responses
+// whose macroId no longer matches, so a cancelled-but-in-flight request cannot
+// render the wrong prompt under the right title.
+switchMap((action) => {
+    const { macroId } = action.payload;
+    const url = `${zeniAPI.apiEndPoints.aiCfoMicroServiceBaseUrl}/1.0/skills/${encodeURIComponent(macroId)}`;
+    return zeniAPI.getJSON(url).pipe(mergeMap((response) => {
+        // Shared mapper and shared guard. This epic used to keep its own `toSkill`
+        // and default a missing prompt to '', so the same malformed body showed an
+        // empty prompt here and failed the read elsewhere — and `isMine` was nearly
+        // added to only two of the three copies.
+        if (isSuccessResponse(response) &&
+            isSkillDetailPayload(response.data)) {
+            return of(fetchSkillDetailSuccess({
+                detail: toSkillDetail(response.data),
+                macroId,
+            }));
+        }
+        return of(fetchSkillDetailFailure({ error: response.status, macroId }));
+    }), catchError((error) => of(fetchSkillDetailFailure({
+        error: createZeniAPIStatus('Unexpected Error', 'Fetch skill detail REST API call failed', error instanceof Error ? { message: error.message } : undefined),
+        macroId,
+    }))));
+}));

package/lib/esm/view/aiCfoView/epics/fetchSkillVersionBodyEpic.js

@@ -0,0 +1,45 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessResponse } from '../../../responsePayload';
+import { fetchSkillVersionBody, fetchSkillVersionBodyFailure, fetchSkillVersionBodySuccess, } from '../aiCfoViewReducer';
+import { hasPromptBody } from './toSkillDetail';
+/**
+ * GET /1.0/skills/{macroId}?version=N — one historical version's prompt.
+ *
+ * Only used to seed a restore. The history list carries metadata only, deliberately: a
+ * 20-version history would otherwise be a 240kB response for a panel that shows dates.
+ */
+export const fetchSkillVersionBodyEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(fetchSkillVersionBody.match), 
+// switchMap: a read, and only the version the user last clicked matters. The reducer
+// also drops a response whose (macroId, version) no longer matches, so a
+// cancelled-but-in-flight request cannot seed the form with the wrong body.
+switchMap((action) => {
+    const { macroId, version } = action.payload;
+    const url = `${zeniAPI.apiEndPoints.aiCfoMicroServiceBaseUrl}/1.0/skills/${encodeURIComponent(macroId)}?version=${encodeURIComponent(String(version))}`;
+    return zeniAPI.getJSON(url).pipe(mergeMap((response) => {
+        // `instructions` checked, not just `data`: the payload TYPE says the field is
+        // required, and the network is under no obligation to agree. Without this the
+        // epic reported success with `instructions: undefined`, and the browser — which
+        // holds the editor closed until a body arrives — showed "Loading this version…"
+        // for ever, with no error and no way forward.
+        if (isSuccessResponse(response) && hasPromptBody(response.data)) {
+            return of(fetchSkillVersionBodySuccess({
+                macroId,
+                version,
+                instructions: response.data.instructions,
+            }));
+        }
+        // A malformed 2xx is a failure. An empty STRING is not malformed and is allowed
+        // through: the editor's own minimum-length rule refuses to save it, so the user
+        // sees a validation message on a form they can fix rather than a dead end.
+        return of(fetchSkillVersionBodyFailure({
+            macroId,
+            version,
+            error: response.status,
+        }));
+    }), catchError((error) => of(fetchSkillVersionBodyFailure({
+        macroId,
+        version,
+        error: createZeniAPIStatus('Unexpected Error', 'Fetch skill version body REST API call failed', error instanceof Error ? { message: error.message } : undefined),
+    }))));
+}));