@zeniai/client-epic-state 5.1.45 → 5.1.46

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

@@ -383,6 +383,36 @@ const aiCfoView = createSlice({
             const { chatSessionId } = action.payload;
             delete draft.deleteChatSessionStateByChatSessionId[chatSessionId];
         },
+        // AI CFO answer feedback (👍/👎). Fire-and-forget: submitFeedbackEpic POSTs to /1.0/feedback
+        // and the server emits the analytics event + routes negatives, so there's no view state to
+        // mutate — the reducers are intentional no-ops; prepare carries the params.
+        submitFeedback: {
+            reducer() { },
+            prepare(chatSessionId, chatMessageId, feedbackType, questionText, answerText, model) {
+                return {
+                    payload: {
+                        chatMessageId,
+                        chatSessionId,
+                        feedbackType,
+                        answerText,
+                        model,
+                        questionText,
+                    },
+                };
+            },
+        },
+        submitFeedbackSuccess: {
+            reducer() { },
+            prepare(chatMessageId) {
+                return { payload: { chatMessageId } };
+            },
+        },
+        submitFeedbackFailure: {
+            reducer() { },
+            prepare(chatMessageId, error) {
+                return { payload: { chatMessageId, error } };
+            },
+        },
         clearInput(draft) {
             draft.uiState.currentInput = '';
         },
@@ -481,5 +511,5 @@ const aiCfoView = createSlice({
         },
     },
 });
-export const { submitQuestion, submitQuestionSuccess, submitQuestionFailure, updateResponseState, updateAiCfoViewScrollPosition, updateCurrentInput, clearInput, 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, clearAiCfoView, updateCotCollapsedState, fetchSuggestedQuestions, fetchSuggestedQuestionsSuccess, fetchSuggestedQuestionsFailure, fetchSkills, fetchSkillsSuccess, fetchSkillsFailure, applyAiCfoSidePanelHostPageTransition, clearAiCfoSidePanelHostPageContext, } = aiCfoView.actions;
+export const { submitQuestion, submitQuestionSuccess, submitQuestionFailure, updateResponseState, updateAiCfoViewScrollPosition, updateCurrentInput, submitFeedback, submitFeedbackSuccess, submitFeedbackFailure, clearInput, 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, clearAiCfoView, updateCotCollapsedState, fetchSuggestedQuestions, fetchSuggestedQuestionsSuccess, fetchSuggestedQuestionsFailure, fetchSkills, fetchSkillsSuccess, fetchSkillsFailure, applyAiCfoSidePanelHostPageTransition, clearAiCfoSidePanelHostPageContext, } = aiCfoView.actions;
 export default aiCfoView.reducer;

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

@@ -2,14 +2,39 @@ import { of } from 'rxjs';
 import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
 import { createZeniAPIStatus, isSuccessResponse } from '../../../responsePayload';
 import { fetchSkills, fetchSkillsFailure, fetchSkillsSuccess, } from '../aiCfoViewReducer';
-const toSkill = (s) => ({
-    macroId: s.macro_id,
-    name: s.name,
-    displayName: s.display_name,
-    description: s.description,
-    semver: s.semver,
-    parameterHints: s.parameter_hints,
-    hasScripts: s.has_scripts,
+const isNonBlankString = (value) => typeof value === 'string' && value.trim() !== '';
+// parameter_hints is a free-form {param: exampleValue(s)} map; flatten its non-blank
+// string values (a single string or an array of them) into display-ready "try: …"
+// phrases. The container check is a runtime guard, not a type check: /1.0/skills is not
+// schema-validated, so a malformed non-object payload would otherwise make Object.values
+// split a string into characters.
+const toExampleHints = (parameterHints) => {
+    if (parameterHints == null ||
+        typeof parameterHints !== 'object' ||
+        Array.isArray(parameterHints)) {
+        return [];
+    }
+    const hints = Object.values(parameterHints).flatMap((value) => {
+        if (isNonBlankString(value)) {
+            return [value.trim()];
+        }
+        if (Array.isArray(value)) {
+            return value.filter(isNonBlankString).map((item) => item.trim());
+        }
+        return [];
+    });
+    // The menu joins these into one flat "try: a · b" line, so a repeated phrase reads as
+    // a broken duplicate to the user — dedupe across parameter keys and array entries.
+    return Array.from(new Set(hints));
+};
+const toSkill = (skillSummaryPayload) => ({
+    macroId: skillSummaryPayload.macro_id,
+    name: skillSummaryPayload.name,
+    displayName: skillSummaryPayload.display_name,
+    description: skillSummaryPayload.description,
+    semver: skillSummaryPayload.semver,
+    exampleHints: toExampleHints(skillSummaryPayload.parameter_hints),
+    hasScripts: skillSummaryPayload.has_scripts,
 });
 /** GET {aiCfoMicroServiceBaseUrl}/1.0/skills — chat-visible skills for the `/` menu. */
 export const fetchSkillsEpic = (actions$, 

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

@@ -0,0 +1,39 @@
+import { of } from 'rxjs';
+import { catchError, filter, groupBy, mergeMap, switchMap } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessStatus, } from '../../../responsePayload';
+import { submitFeedback, submitFeedbackFailure, submitFeedbackSuccess, } from '../aiCfoViewReducer';
+/**
+ * Thin wiring for AI CFO answer feedback (👍/👎). Dispatch `submitFeedback(...)` (defined on the
+ * aiCfoView slice) to POST to the AI CFO micro-service `/1.0/feedback` endpoint, which emits the
+ * analytics event server-side and routes negatives to the review queue. The capture-prompt UI
+ * that dispatches this lands in a fast-follow PR.
+ */
+export const submitFeedbackEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(submitFeedback.match), 
+// Per-message dedup: group by chatMessageId so rapid repeat clicks on the SAME answer cancel
+// the in-flight request (switchMap) — no duplicate POST / analytics / Slack row — while
+// feedback on different answers still runs concurrently (separate groups under mergeMap).
+groupBy((action) => action.payload.chatMessageId), mergeMap((perMessage$) => perMessage$.pipe(switchMap((action) => {
+    const { chatMessageId, chatSessionId, feedbackType, answerText, model, questionText, } = action.payload;
+    const body = {
+        chat_message_id: chatMessageId,
+        chat_session_id: chatSessionId,
+        feedback_type: feedbackType,
+        ...(answerText != null && { answer_text: answerText }),
+        ...(model != null && { model }),
+        ...(questionText != null && { question_text: questionText }),
+    };
+    return zeniAPI
+        .postAndGetJSON(`${zeniAPI.apiEndPoints.aiCfoMicroServiceBaseUrl}/1.0/feedback`, body)
+        .pipe(
+    // Status-only success check (no `data`): /1.0/feedback returns a 2xx with status and no
+    // body, so isSuccessResponse (which requires response.data) would wrongly fail it.
+    mergeMap((response) => isSuccessStatus(response)
+        ? of(submitFeedbackSuccess(chatMessageId))
+        : of(submitFeedbackFailure(chatMessageId, response.status))), catchError((error) => of(submitFeedbackFailure(chatMessageId, createZeniAPIStatus(
+    // message (detailed) first, then the short title — per createZeniAPIStatus(message, title).
+    // JSON.stringify(Error) drops the (non-enumerable) message — extract it explicitly.
+    'Feedback REST API call errored out: ' +
+        (error instanceof Error
+            ? error.message
+            : String(error)), 'Unexpected Error')))));
+}))));

package/lib/esm/view/companyTaskManagerView/epics/fetchCompanyTaskManagerViewEpic.js

@@ -18,6 +18,9 @@ export const fetchCompanyTaskManagerViewEpic = (actions$, _state$, zeniAPI) => a
         ...(filters?.categories != null && filters.categories.length > 0
             ? { filter_by: toFilterByPayload(filters) }
             : {}),
+        task_group_scopes: filters?.taskGroupScopes != null && filters.taskGroupScopes.length > 0
+            ? filters.taskGroupScopes
+            : ['internal'],
     };
     return zeniAPI
         .getJSON(`${zeniAPI.apiEndPoints.tenantMicroServiceBaseUrl}/1.0/cockpit-panels/tasks-es?query=${encodeURIComponent(JSON.stringify(queryValue))}`)

package/lib/esm/view/companyTaskManagerView/epics/fetchTaskManagerMetricsEpic.js

@@ -3,7 +3,13 @@ import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
 import { isSuccessResponse } from '../../../responsePayload';
 import { fetchTaskManagerMetrics, updateTaskManagerMetrics, updateTaskManagerMetricsOnFailure, } from '../companyTaskManagerViewReducer';
 export const fetchTaskManagerMetricsEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(fetchTaskManagerMetrics.match), switchMap(() => {
-    const query = JSON.stringify({ is_filter_by_logged_in_user: true });
+    // Include subtasks so the cockpit count matches the customer dashboard
+    // pending count. The dashboard counts every task (subtasks included);
+    // cockpit's default of include_subtasks=false otherwise undercounts.
+    const query = JSON.stringify({
+        is_filter_by_logged_in_user: true,
+        include_subtasks: true,
+    });
     return zeniAPI
         .getJSON(`${zeniAPI.apiEndPoints.tenantMicroServiceBaseUrl}/1.0/cockpit-panels/tasks-es-metrics?query=${encodeURIComponent(query)}`)
         .pipe(mergeMap((response) => {

package/lib/esm/view/expenseAutomationView/reducers/transactionsViewReducer.js

@@ -168,6 +168,13 @@ const expenseAutomationTransactionsView = createSlice({
                 if (searchString !== undefined) {
                     draft.transactionCategorizationView[selectedTab].uiState.searchString =
                         searchString;
+                    // When search is cleared, drop all sub-tab snapshots. A snapshot
+                    // captured while search was active holds filtered row IDs — restoring
+                    // it after the clear would show stale search results instead of the
+                    // full unfiltered list.
+                    if (searchString === '' && selectedTab === 'autoCategorized') {
+                        draft.autoCategorizedSubTabCache = {};
+                    }
                 }
                 draft.transactionCategorizationView[selectedTab].error = undefined;
                 const monthYearPeriod = {

package/lib/esm/view/taskManager/taskDetailView/epics/createSubTaskEpic.js

@@ -0,0 +1,96 @@
+import { from, of } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { convertHHMMStrToMinutes } from '../../../../commonStateTypes/fiscalYearHelpers/formatMinutesToFromHHMM';
+import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
+import { appendSubTaskId, updateTasks, } from '../../../../entity/task/taskReducer';
+import { getTaskById } from '../../../../entity/task/taskSelector';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { updateTaskListOnNewTaskCreationSuccess } from '../../taskListView/taskListReducer';
+import { createSubTask, createSubTaskSuccessOrFailure, } from '../taskDetailReducer';
+export const createSubTaskEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(createSubTask.match), mergeMap((action) => {
+    const state = state$.value;
+    const parentTask = getTaskById(state.taskState, action.payload.parentTaskId);
+    // Subtasks inherit every parent group membership, not just the first,
+    // so the subtask surfaces in all the same buckets as its parent.
+    const parentTaskGroupIds = parentTask?.taskGroupIds ?? [];
+    const parentTaskGroupId = parentTaskGroupIds[0];
+    const isTaskListFetched = state.taskListState.fetchState === 'Completed';
+    const payload = prepareSubTaskPayload(action.payload, parentTaskGroupIds);
+    return zeniAPI
+        .postAndGetJSON(`${zeniAPI.apiEndPoints.taskMicroServiceBaseUrl}/1.0/task-manager/tasks`, payload)
+        .pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) &&
+            response.data != null &&
+            response.data.tasks.length > 0) {
+            const newTaskId = response.data.tasks[0].task_id;
+            const actions = [
+                updateTasks(response.data.tasks),
+                appendSubTaskId({
+                    parentTaskId: action.payload.parentTaskId,
+                    subTaskId: newTaskId,
+                }),
+                createSubTaskSuccessOrFailure({
+                    fetchState: 'Completed',
+                    newTaskId,
+                }),
+                openSnackbar({
+                    messageSection: 'create_sub_task',
+                    messageText: 'success',
+                    type: 'success',
+                }),
+            ];
+            // The task list is keyed on parent tasks (no parent_task_id)
+            // — subtasks belong to their parent's children list, not the
+            // top-level list. Pushing a subtask into the list would
+            // surface it as an orphan row at the top of the group.
+            // Only fire the list-update for actual parent tasks.
+            const createdTask = response.data.tasks[0];
+            const isSubtask = createdTask.parent_task_id != null &&
+                createdTask.parent_task_id !== '';
+            if (!isSubtask &&
+                isTaskListFetched === true &&
+                parentTaskGroupId != null) {
+                actions.push(updateTaskListOnNewTaskCreationSuccess({
+                    taskGroupId: parentTaskGroupId,
+                    task: createdTask,
+                }));
+            }
+            return from(actions);
+        }
+        else {
+            return of(createSubTaskSuccessOrFailure({
+                fetchState: 'Error',
+                error: response.status,
+            }), openSnackbar({
+                messageSection: 'create_sub_task',
+                messageText: 'failed',
+                type: 'error',
+                variables: [
+                    {
+                        variableName: '_api-error_',
+                        variableValue: response.status.message,
+                    },
+                ],
+            }));
+        }
+    }), catchError((error) => of(createSubTaskSuccessOrFailure({
+        fetchState: 'Error',
+        error: createZeniAPIStatus('Unexpected Error', 'Create Sub Task REST API call errored out' +
+            JSON.stringify(error)),
+    }))));
+}));
+const prepareSubTaskPayload = (subTask, parentTaskGroupIds) => ({
+    name: subTask.name,
+    assignees: subTask.assignee,
+    description: subTask.description,
+    priority: subTask.priority,
+    status: subTask.status,
+    tags: subTask.tagIds,
+    time_spent: convertHHMMStrToMinutes(subTask.timeSpent),
+    group_assignees: subTask.groupAssignees,
+    parent_task_id: subTask.parentTaskId,
+    // Inherit every parent group, not just the first — see callsite for
+    // the two-scope rationale.
+    task_group_ids: parentTaskGroupIds,
+    due_date: subTask.dueDate?.format('YYYY-MM-DD') ?? null,
+});

package/lib/esm/view/taskManager/taskDetailView/epics/fetchSubTasksEpic.js

@@ -0,0 +1,53 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { setSubTaskIds, updateTasks } from '../../../../entity/task/taskReducer';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { fetchSubTasks, updateSubTasks, updateSubTasksFetchStatus, } from '../taskDetailReducer';
+export const fetchSubTasksEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(fetchSubTasks.match), 
+// Use mergeMap, not switchMap: switchMap cancels in-flight requests for
+// the previous parent without dispatching success or failure, leaving
+// subTaskListFetchStatusByParentId stuck at In-Progress and blocking the
+// detail page's combined fetchStatus via reduceAnyFetchState. Per-parent
+// races on the same parentTaskId are handled last-write-wins downstream.
+mergeMap((action) => {
+    const { parentTaskId } = action.payload;
+    const query = JSON.stringify({
+        task_type: 'subtasks',
+        parent_task_id: parentTaskId,
+    });
+    return zeniAPI
+        .getJSON(`${zeniAPI.apiEndPoints.taskMicroServiceBaseUrl}/1.0/task-manager/tasks?query=${encodeURIComponent(query)}`)
+        .pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) && response.data != null) {
+            const { tasks } = response.data;
+            // Keep the parent's `subTasksIds` in sync with the fetched
+            // bucket. Without this, the parent entity record can drift
+            // out of sync with what the children fetch returned —
+            // e.g. a server-side delete won't drop from the parent
+            // record until the next list re-fetch.
+            const fetchedChildIds = tasks
+                .filter((t) => t.parent_task_id === parentTaskId)
+                .map((t) => t.task_id);
+            return of(updateTasks(tasks), setSubTaskIds({
+                parentTaskId,
+                subTaskIds: fetchedChildIds,
+            }), updateSubTasks({
+                parentTaskId,
+            }));
+        }
+        else {
+            return of(updateSubTasksFetchStatus({
+                parentTaskId,
+                fetchState: 'Error',
+                error: response.status,
+            }));
+        }
+    }), catchError((error) => {
+        return of(updateSubTasksFetchStatus({
+            parentTaskId,
+            fetchState: 'Error',
+            error: createZeniAPIStatus('Unexpected Error', 'Fetch Sub Tasks REST API call errored out' +
+                JSON.stringify(error)),
+        }));
+    }));
+}));

package/lib/esm/view/taskManager/taskDetailView/epics/initializeTaskToLocalStoreEpic.js

@@ -28,6 +28,7 @@ export const initializeTaskToLocalStoreEpic = (actions$, state$) => actions$.pip
             recurringStartDate: task.recurringStartDate,
             timeSpent: task.timeSpent,
             isPrivate: task.isPrivate,
+            taskGroupId: task.taskGroupIds[0],
         };
         const actions = [
             saveTaskUpdatesToLocalStore({ taskDetailLocalData, taskId }),

package/lib/esm/view/taskManager/taskDetailView/epics/saveTaskDetailEpic.js

@@ -6,23 +6,52 @@ import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
 import { updateTasks } from '../../../../entity/task/taskReducer';
 import { getTaskById } from '../../../../entity/task/taskSelector';
 import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
-import { updateTaskListOnNewTaskCreationSuccess } from '../../taskListView/taskListReducer';
+import { removeTaskFromGroupBucket, updateTaskListOnNewTaskCreationSuccess, } from '../../taskListView/taskListReducer';
 import { saveTaskDetail, saveTaskSuccessOrFailure } from '../taskDetailReducer';
 export const saveTaskDetailEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(saveTaskDetail.match), mergeMap((action) => {
     const { taskId, taskGroupId } = action.payload;
     const state = state$.value;
     const isTaskListFetched = state.taskListState.fetchState === 'Completed';
-    const updatedTaskGroupId = taskId == null
-        ? taskGroupId
-        : getTaskById(state.taskState, taskId)?.taskGroupIds[0];
-    const payload = prepareTaskPayload(state, taskId, updatedTaskGroupId);
+    // On edit, prefer the locally-edited group; fall back to the entity's
+    // current group. On create, use the taskGroupId from the action payload.
+    const localTaskGroupId = taskId != null
+        ? state.taskDetailState.editTaskStateById[taskId]?.taskDetailLocalData
+            ?.taskGroupId
+        : undefined;
+    // groupWasCleared distinguishes "user explicitly cleared the group"
+    // (localTaskGroupId === null → send []) from "user did not touch it"
+    // (undefined → fall back to entity). Without this, the `??` fallback
+    // would resurrect the stale entity value after a clear.
+    const groupWasCleared = taskId != null && localTaskGroupId === null;
+    const entityTaskGroupIds = taskId != null
+        ? (getTaskById(state.taskState, taskId)?.taskGroupIds ?? [])
+        : [];
+    // Distinguish three save shapes:
+    //   - cleared → []
+    //   - user picked a different group locally → [localTaskGroupId]
+    //   - no local edit → entire entityTaskGroupIds (preserves multi-
+    //     group membership; without this, unrelated field edits silently
+    //     drop extra groups).
+    const localGroupChanged = localTaskGroupId != null;
+    const taskGroupIdsForPayload = groupWasCleared
+        ? []
+        : localGroupChanged
+            ? [localTaskGroupId]
+            : taskId != null
+                ? entityTaskGroupIds
+                : taskGroupId != null
+                    ? [taskGroupId]
+                    : [];
+    // Keep `updatedTaskGroupId` (single id) for downstream list-update
+    // dispatches that still bucket against one group at a time.
+    const updatedTaskGroupId = taskGroupIdsForPayload[0];
+    const payload = prepareTaskPayload(state, taskId, taskGroupIdsForPayload);
     const saveTaskApi = taskId != null
         ? zeniAPI.putAndGetJSON(`${zeniAPI.apiEndPoints.taskMicroServiceBaseUrl}/1.0/task-manager/tasks/${taskId}`, payload)
         : zeniAPI.postAndGetJSON(`${zeniAPI.apiEndPoints.taskMicroServiceBaseUrl}/1.0/task-manager/tasks`, payload);
     return saveTaskApi.pipe(mergeMap((response) => {
         if (isSuccessResponse(response) &&
             response.data != null &&
-            updatedTaskGroupId != null &&
             response.data.tasks.length > 0) {
             const newTaskId = response.data.tasks[0].task_id;
             const actions = [
@@ -33,7 +62,24 @@ export const saveTaskDetailEpic = (actions$, state$, zeniAPI) => actions$.pipe(f
                     taskId,
                 }),
             ];
-            if (isTaskListFetched === true) {
+            // Only suppress the list-insert on the live/completed tabs
+            // when the saved task's status no longer matches the tab —
+            // otherwise doUpdateTaskList writes the row back into the
+            // current tab's grouping arrays even after updateTasks moved
+            // it to Completed. Archived/snoozed/deleted are owned by
+            // their dedicated actions and must keep the pre-PR optimistic
+            // update path so their grouping arrays don't go stale.
+            const savedTask = response.data.tasks[0];
+            const savedIsCompleted = savedTask.status?.code === 'resolved';
+            const activeTab = state.taskListState.currentTab;
+            const isLiveOrCompletedTab = activeTab === 'live' || activeTab === 'completed';
+            const statusMatchesActiveTab = !isLiveOrCompletedTab ||
+                (savedIsCompleted && activeTab === 'completed') ||
+                (!savedIsCompleted && activeTab === 'live');
+            if (isTaskListFetched === true &&
+                groupWasCleared === false &&
+                updatedTaskGroupId != null &&
+                statusMatchesActiveTab === true) {
                 actions.push(updateTaskListOnNewTaskCreationSuccess({
                     taskGroupId: updatedTaskGroupId,
                     task: response.data.tasks[0],
@@ -42,6 +88,21 @@ export const saveTaskDetailEpic = (actions$, state$, zeniAPI) => actions$.pipe(f
                         : undefined,
                 }));
             }
+            else if (isTaskListFetched === true &&
+                groupWasCleared === true &&
+                taskId != null) {
+                // Group was cleared — skip the list-insert action (no
+                // destination bucket) and explicitly drop the row from every
+                // previously-held group so the list re-renders without the
+                // stale entry under the old group until next refetch.
+                const previousTask = getTaskById(state.taskState, taskId);
+                previousTask?.taskGroupIds.forEach((previousGroupId) => {
+                    actions.push(removeTaskFromGroupBucket({
+                        taskId,
+                        taskGroupId: previousGroupId,
+                    }));
+                });
+            }
             return from(actions);
         }
         else {
@@ -67,7 +128,7 @@ export const saveTaskDetailEpic = (actions$, state$, zeniAPI) => actions$.pipe(f
         error: createZeniAPIStatus('Unexpected Error', 'Save Task REST API call errored out' + JSON.stringify(error)),
     }))));
 }));
-const prepareTaskPayload = (state, taskId, taskGroupId) => {
+const prepareTaskPayload = (state, taskId, taskGroupIds) => {
     const { taskDetailState, taskState } = state;
     const syncToken = taskId != null ? (getTaskById(taskState, taskId)?.syncToken ?? '') : '';
     const sourceState = taskId != null
@@ -96,7 +157,7 @@ const prepareTaskPayload = (state, taskId, taskGroupId) => {
             ? (localData.recurringDaysOfWeek ?? [])
             : [],
         sync_token: syncToken,
-        task_group_ids: taskGroupId != null ? [taskGroupId] : [],
+        task_group_ids: taskGroupIds,
         time_spent: convertHHMMStrToMinutes(localData.timeSpent),
         group_assignees: localData.groupAssignees,
         ...(taskId == null ? { is_private: localData.isPrivate ?? false } : {}),

package/lib/esm/view/taskManager/taskDetailView/taskDetailReducer.js

@@ -6,6 +6,11 @@ import { initialTaskDetail, } from './taskDetail';
 export const initialState = {
     newTaskState: initialTaskDetail,
     editTaskStateById: {},
+    subTaskCreateStatus: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    subTaskListFetchStatusByParentId: {},
     taskHistoryById: {},
 };
 const taskDetailView = createSlice({
@@ -50,7 +55,7 @@ const taskDetailView = createSlice({
         updateEditTaskFetchStatus(draft, action) {
             const { taskId, fetchState, error } = action.payload;
             draft.editTaskStateById[taskId] = {
-                ...draft.editTaskStateById[taskId],
+                ...(draft.editTaskStateById[taskId] ?? initialTaskDetail),
                 fetchTaskStatus: {
                     fetchState,
                     error: fetchState === 'Error' ? error : undefined,
@@ -318,10 +323,59 @@ const taskDetailView = createSlice({
                 error,
             };
         },
+        createSubTask: {
+            reducer(draft) {
+                draft.subTaskCreateStatus = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+            prepare(payload) {
+                return { payload };
+            },
+        },
+        createSubTaskSuccessOrFailure(draft, action) {
+            const { fetchState, error } = action.payload;
+            draft.subTaskCreateStatus = {
+                fetchState,
+                error,
+            };
+        },
+        resetSubTaskCreateStatus(draft) {
+            draft.subTaskCreateStatus = {
+                ...initialState.subTaskCreateStatus,
+            };
+        },
+        fetchSubTasks: {
+            reducer(draft, action) {
+                const { parentTaskId } = action.payload;
+                draft.subTaskListFetchStatusByParentId[parentTaskId] = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+            prepare(parentTaskId) {
+                return { payload: { parentTaskId } };
+            },
+        },
+        updateSubTasks(draft, action) {
+            const { parentTaskId } = action.payload;
+            draft.subTaskListFetchStatusByParentId[parentTaskId] = {
+                fetchState: 'Completed',
+                error: undefined,
+            };
+        },
+        updateSubTasksFetchStatus(draft, action) {
+            const { parentTaskId, fetchState, error } = action.payload;
+            draft.subTaskListFetchStatusByParentId[parentTaskId] = {
+                fetchState,
+                error,
+            };
+        },
         clearTaskDetail(draft) {
             Object.assign(draft, initialState);
         },
     },
 });
-export const { fetchTaskDetailPage, fetchTaskDetail, initializeTaskToLocalStore, updateEditTaskFetchStatus, saveTaskUpdatesToLocalStore, discardTaskUpdatesInLocalStore, saveTaskDetail, archiveTask, archiveTaskSuccessOrFailure, saveTaskSuccessOrFailure, deleteTask, removeTaskDetail, deleteTaskSuccessOrFailure, snoozeTask, snoozeTaskSuccessOrFailure, unsnoozeTask, fetchTaskHistory, updateTaskHistory, updateTaskHistoryFetchStatus, clearTaskDetail, updateCreatedTagToLocalStore, updateDeletedTagToLocalStore, } = taskDetailView.actions;
+export const { fetchTaskDetailPage, fetchTaskDetail, initializeTaskToLocalStore, updateEditTaskFetchStatus, saveTaskUpdatesToLocalStore, discardTaskUpdatesInLocalStore, saveTaskDetail, archiveTask, archiveTaskSuccessOrFailure, saveTaskSuccessOrFailure, createSubTask, createSubTaskSuccessOrFailure, resetSubTaskCreateStatus, fetchSubTasks, updateSubTasks, updateSubTasksFetchStatus, deleteTask, removeTaskDetail, deleteTaskSuccessOrFailure, snoozeTask, snoozeTaskSuccessOrFailure, unsnoozeTask, fetchTaskHistory, updateTaskHistory, updateTaskHistoryFetchStatus, clearTaskDetail, updateCreatedTagToLocalStore, updateDeletedTagToLocalStore, } = taskDetailView.actions;
 export default taskDetailView.reducer;