TaskOutcomeMemory.cpp

Go to the documentation of this file.

#include "TaskOutcomeMemory.h"
 
#include <algorithm>
#include <numeric>
#include <vector>
 
#include <ArmarXCore/core/logging/Logging.h>
 
#include <RobotAPI/libraries/armem/server/MemoryToIceAdapter.h>
#include <RobotAPI/libraries/armem_task_outcome/aron/TaskOutcome.aron.generated.h>
#include <RobotAPI/libraries/armem_task_outcome/aron_conversions.h>
#include <RobotAPI/libraries/armem_task_outcome/types.h>
 
namespace armarx
{
 
    namespace
    {
 
        std::string
        outcomeTypeToString(armem::task_outcome::TaskOutcomeType type)
        {
            switch (type)
            {
                case armem::task_outcome::TaskOutcomeType::SUCCESS:
                    return "SUCCESS";
                case armem::task_outcome::TaskOutcomeType::FAILURE:
                    return "FAILURE";
                case armem::task_outcome::TaskOutcomeType::ABORTED:
                    return "ABORTED";
                case armem::task_outcome::TaskOutcomeType::SUSPENDED:
                    return "SUSPENDED";
                default:
                    return "UNKNOWN";
            }
        }
 
        std::string
        taskTypeToString(armem::task_outcome::TaskType type)
        {
            switch (type)
            {
                case armem::task_outcome::TaskType::GRASPING_FAMILIAR:
                    return "GRASPING_FAMILIAR";
                case armem::task_outcome::TaskType::GRASPING_KNOWN:
                    return "GRASPING_KNOWN";
                case armem::task_outcome::TaskType::MANIPULATION:
                    return "MANIPULATION";
                case armem::task_outcome::TaskType::VERBALIZATION:
                    return "VERBALIZATION";
                case armem::task_outcome::TaskType::DETECTION:
                    return "DETECTION";
                case armem::task_outcome::TaskType::NAVIGATION:
                    return "NAVIGATION";
                case armem::task_outcome::TaskType::SPEAKING:
                    return "SPEAKING";
                case armem::task_outcome::TaskType::SPECIAL:
                    return "SPECIAL";
                default:
                    return "UNKNOWN";
            }
        }
 
        std::string
        failureTypeSummary(const armem::task_outcome::FailureType& type)
        {
            std::vector<std::string> active;
 
            if (type.planning.noTrajectoryFound)
                active.push_back("Planning: NoTrajectoryFound");
            if (type.planning.noGraspFound)
                active.push_back("Planning: NoGraspFound");
            if (type.planning.special)
                active.push_back("Planning: Special");
 
            if (type.knowledge.perception.objectNotDetected)
                active.push_back("Knowledge/Perception: ObjectNotDetected");
            if (type.knowledge.perception.cameraNotWorking)
                active.push_back("Knowledge/Perception: CameraNotWorking");
            if (type.knowledge.knowledgeRetrieval.technicalFailure)
                active.push_back("Knowledge/Retrieval: TechnicalFailure");
            if (type.knowledge.knowledgeRetrieval.knowledgeNotInMemory)
                active.push_back("Knowledge/Retrieval: KnowledgeNotInMemory");
 
            if (type.execution.robotNotMoving)
                active.push_back("Execution: RobotNotMoving");
            if (type.execution.handNotClosing)
                active.push_back("Execution: HandNotClosing");
            if (type.execution.graspingFailureDetected)
                active.push_back("Execution: GraspingFailureDetected");
 
            if (type.interaction.noHumanForHandover)
                active.push_back("Interaction: NoHumanForHandover");
            if (type.interaction.desiredObjectNotAtLocation)
                active.push_back("Interaction: DesiredObjectNotAtLocation");
            if (type.interaction.communicationFailure)
                active.push_back("Interaction: CommunicationFailure");
 
            if (type.interruption.userStopped)
                active.push_back("Interruption: UserStopped");
 
            if (type.subskillFailure.failed)
                active.push_back("SubskillFailure: " + type.subskillFailure.subskillName);
 
            if (active.empty())
            {
                return "(none)";
            }
 
            std::string result;
            for (size_t i = 0; i < active.size(); ++i)
            {
                if (i > 0)
                    result += ", ";
                result += active[i];
            }
            return result;
        }
 
        armem::task_outcome::TaskOutcomeType
        stringToOutcomeType(const std::string& str)
        {
            if (str == "SUCCESS")
                return armem::task_outcome::TaskOutcomeType::SUCCESS;
            if (str == "FAILURE")
                return armem::task_outcome::TaskOutcomeType::FAILURE;
            if (str == "ABORTED")
                return armem::task_outcome::TaskOutcomeType::ABORTED;
            if (str == "SUSPENDED")
                return armem::task_outcome::TaskOutcomeType::SUSPENDED;
            return armem::task_outcome::TaskOutcomeType::UNKNOWN;
        }
 
        std::string
        truncateStr(const std::string& str, size_t maxLen)
        {
            if (str.size() <= maxLen)
                return str;
            if (maxLen <= 3)
                return str.substr(0, maxLen);
            return str.substr(0, maxLen - 3) + "...";
        }
 
    } // namespace
 
    TaskOutcomeMemory::TaskOutcomeMemory() :
        ReadWritePluginUser(),
        taskOutcomeSegment(iceAdapter())
    {
    }
 
    armarx::PropertyDefinitionsPtr
    TaskOutcomeMemory::createPropertyDefinitions()
    {
        armarx::PropertyDefinitionsPtr defs =
            new ComponentPropertyDefinitions(getConfigIdentifier());
 
        setMemoryName(MemoryName);
 
        taskOutcomeSegment.defineProperties(defs, "outcome.");
 
        return defs;
    }
 
    std::string
    TaskOutcomeMemory::getDefaultName() const
    {
        return "TaskOutcomeMemory";
    }
 
    void
    TaskOutcomeMemory::onInitComponent()
    {
        taskOutcomeSegment.init();
    }
 
    void
    TaskOutcomeMemory::onConnectComponent()
    {
        createRemoteGuiTab();
        RemoteGui_startRunningTask();
    }
 
    void
    TaskOutcomeMemory::onDisconnectComponent()
    {
    }
 
    void
    TaskOutcomeMemory::onExitComponent()
    {
    }
 
    armem::data::CommitResult
    TaskOutcomeMemory::commit(const armem::data::Commit& commit, const Ice::Current& current)
    {
        armem::data::CommitResult result = ReadWritePluginUser::commit(commit, current);
        newDataAvailable = true;
        return result;
    }
 
    void
    TaskOutcomeMemory::createRemoteGuiTab()
    {
        using namespace armarx::RemoteGui::Client;
 
        // --- Settings row ---
        tab.maxEntries.setRange(1, 100);
        tab.maxEntries.setValue(guiMaxEntries);
 
        GridLayout settingsGrid;
        {
            int col = 0;
            settingsGrid.add(Label("Max Entries"), Pos{0, col++});
            settingsGrid.add(tab.maxEntries, Pos{0, col++});
        }
 
        GroupBox settingsGroup;
        settingsGroup.setLabel("Settings");
        settingsGroup.addChild(settingsGrid);
 
        // --- Collect outcomes with MemoryIDs ---
        std::vector<armem::task_outcome::TaskOutcome> outcomes;
        std::vector<armem::MemoryID> outcomeIds;
 
        if (workingMemory().hasCoreSegment("TaskOutcome"))
        {
            workingMemory().getCoreSegment("TaskOutcome").forEachProviderSegment(
                [&outcomes, &outcomeIds](const auto& providerSegment)
                {
                    providerSegment.forEachEntity(
                        [&outcomes, &outcomeIds](const auto& entity)
                        {
                            entity.forEachSnapshot(
                                [&outcomes, &outcomeIds](const auto& snapshot)
                                {
                                    snapshot.forEachInstance(
                                        [&outcomes, &outcomeIds](const auto& instance)
                                        {
                                            try
                                            {
                                                const auto dto =
                                                    armarx::task_outcome::arondto::
                                                        TaskOutcome::FromAron(
                                                            instance.data());
                                                armem::task_outcome::TaskOutcome bo;
                                                armem::task_outcome::fromAron(dto, bo);
                                                outcomes.push_back(bo);
                                                outcomeIds.push_back(instance.id());
                                            }
                                            catch (...)
                                            {
                                            }
                                        });
                                });
                        });
                });
        }
 
        // Take the last N entries.
        if (static_cast<int>(outcomes.size()) > guiMaxEntries)
        {
            const int excess = static_cast<int>(outcomes.size()) - guiMaxEntries;
            outcomes.erase(outcomes.begin(), outcomes.begin() + excess);
            outcomeIds.erase(outcomeIds.begin(), outcomeIds.begin() + excess);
        }
 
        // Sort newest first.
        {
            std::vector<size_t> idx(outcomes.size());
            std::iota(idx.begin(), idx.end(), 0);
            std::sort(idx.begin(),
                      idx.end(),
                      [&outcomes](size_t a, size_t b)
                      { return outcomes[a].endTime > outcomes[b].endTime; });
 
            std::vector<armem::task_outcome::TaskOutcome> sortedOutcomes(outcomes.size());
            std::vector<armem::MemoryID> sortedIds(outcomeIds.size());
            for (size_t i = 0; i < idx.size(); ++i)
            {
                sortedOutcomes[i] = std::move(outcomes[idx[i]]);
                sortedIds[i] = std::move(outcomeIds[idx[i]]);
            }
            outcomes = std::move(sortedOutcomes);
            outcomeIds = std::move(sortedIds);
        }
 
        // Clamp selected index to valid range.
        if (selectedOutcomeIndex >= static_cast<int>(outcomes.size()))
        {
            selectedOutcomeIndex = -1;
        }
 
        displayedOutcomeIds = outcomeIds;
 
        // --- Results table with selection column ---
        tab.selectButtons.clear();
 
        GridLayout resultsGrid;
        {
            int row = 0;
 
            // Header row
            resultsGrid.add(Label(""), Pos{row, 0});
            resultsGrid.add(Label("Name"), Pos{row, 1});
            resultsGrid.add(Label("Status"), Pos{row, 2});
            resultsGrid.add(Label("Failure Types"), Pos{row, 3});
            resultsGrid.add(Label("Skill Type"), Pos{row, 4});
            resultsGrid.add(Label("Time"), Pos{row, 5});
            resultsGrid.add(Label("Recovered"), Pos{row, 6});
            resultsGrid.add(Label("Error"), Pos{row, 7});
            row++;
 
            for (int i = 0; i < static_cast<int>(outcomes.size()); ++i)
            {
                const auto& outcome = outcomes[i];
 
                auto& btn = tab.selectButtons[i];
                btn.setLabel("select");
                btn.setValue(i == selectedOutcomeIndex);
 
                const std::string failureStr =
                    outcome.failureInfo.has_value()
                        ? failureTypeSummary(outcome.failureInfo->failureType)
                        : "-";
 
                const std::string recoveredStr =
                    outcome.couldRecover.has_value()
                        ? (outcome.couldRecover.value() ? "yes" : "no")
                        : "-";
 
                resultsGrid.add(btn, Pos{row, 0});
                resultsGrid.add(Label(truncateStr(outcome.taskName, 20)), Pos{row, 1});
                resultsGrid.add(
                    Label(outcomeTypeToString(outcome.outcomeType)), Pos{row, 2});
                resultsGrid.add(Label(truncateStr(failureStr, 50)), Pos{row, 3});
                resultsGrid.add(Label(taskTypeToString(outcome.taskType)), Pos{row, 4});
                resultsGrid.add(Label(outcome.endTime.toTimeString()), Pos{row, 5});
                resultsGrid.add(Label(recoveredStr), Pos{row, 6});
                resultsGrid.add(
                    Label(truncateStr(outcome.errorMessage.value_or("-"), 35)), Pos{row, 7});
                row++;
            }
        }
 
        const std::string resultsLabel =
            "Task Outcomes (" + std::to_string(outcomes.size()) + " entries)";
        GroupBox resultsGroup;
        resultsGroup.setLabel(resultsLabel);
        resultsGroup.addChild(resultsGrid);
 
        // --- Detail panel for selected outcome ---
        // Max length for detail value labels to prevent the left column from
        // becoming too wide and squeezing the edit panel on the right.
        constexpr size_t detailMaxLen = 80;
 
        GroupBox detailGroup;
        if (selectedOutcomeIndex >= 0 &&
            selectedOutcomeIndex < static_cast<int>(outcomes.size()))
        {
            const auto& sel = outcomes[selectedOutcomeIndex];
            detailGroup.setLabel("Selected: " + sel.taskName);
 
            GridLayout detailGrid;
            int row = 0;
 
            detailGrid.add(Label("Task Name"), Pos{row, 0});
            detailGrid.add(Label(truncateStr(sel.taskName, detailMaxLen)), Pos{row, 1});
            row++;
 
            detailGrid.add(Label("Outcome"), Pos{row, 0});
            detailGrid.add(Label(outcomeTypeToString(sel.outcomeType)), Pos{row, 1});
            row++;
 
            detailGrid.add(Label("Task Type"), Pos{row, 0});
            detailGrid.add(Label(taskTypeToString(sel.taskType)), Pos{row, 1});
            row++;
 
            if (sel.specialTaskTypeDescription.has_value())
            {
                detailGrid.add(Label("Special Type"), Pos{row, 0});
                detailGrid.add(Label(truncateStr(sel.specialTaskTypeDescription.value(), detailMaxLen)), Pos{row, 1});
                row++;
            }
 
            detailGrid.add(Label("Agent"), Pos{row, 0});
            detailGrid.add(Label(truncateStr(sel.agent, detailMaxLen)), Pos{row, 1});
            row++;
 
            detailGrid.add(Label("Start Time"), Pos{row, 0});
            detailGrid.add(Label(sel.startTime.toTimeString()), Pos{row, 1});
            row++;
 
            detailGrid.add(Label("End Time"), Pos{row, 0});
            detailGrid.add(Label(sel.endTime.toTimeString()), Pos{row, 1});
            row++;
 
            detailGrid.add(Label("Error"), Pos{row, 0});
            detailGrid.add(Label(truncateStr(sel.errorMessage.value_or("-"), detailMaxLen)), Pos{row, 1});
            row++;
 
            {
                const std::string failureStr = sel.failureInfo.has_value()
                    ? failureTypeSummary(sel.failureInfo->failureType)
                    : "(none)";
 
                detailGrid.add(Label("Failure Types"), Pos{row, 0});
                detailGrid.add(Label(truncateStr(failureStr, detailMaxLen)), Pos{row, 1});
                row++;
            }
 
            if (sel.failureInfo.has_value() &&
                sel.failureInfo->specialFailureDescription.has_value())
            {
                detailGrid.add(Label("Failure Desc"), Pos{row, 0});
                detailGrid.add(
                    Label(truncateStr(sel.failureInfo->specialFailureDescription.value(), detailMaxLen)),
                    Pos{row, 1});
                row++;
            }
 
            detailGrid.add(Label("Could Recover"), Pos{row, 0});
            detailGrid.add(
                Label(sel.couldRecover.has_value()
                          ? (sel.couldRecover.value() ? "true" : "false")
                          : "-"),
                Pos{row, 1});
            row++;
 
            if (sel.recoveryInfo.has_value())
            {
                detailGrid.add(Label("Recovery Time"), Pos{row, 0});
                detailGrid.add(
                    Label(sel.recoveryInfo->recoveryTime.toTimeString()), Pos{row, 1});
                row++;
 
                detailGrid.add(Label("Recovery Measure"), Pos{row, 0});
                detailGrid.add(
                    Label(truncateStr(sel.recoveryInfo->recoveryMeasure, detailMaxLen)),
                    Pos{row, 1});
                row++;
            }
 
            detailGrid.add(Label("Skill"), Pos{row, 0});
            detailGrid.add(Label(truncateStr(sel.context.skillName, detailMaxLen)), Pos{row, 1});
            row++;
 
            if (sel.context.skillExecutionStartedTimestamp.has_value())
            {
                detailGrid.add(Label("Skill Exec Started"), Pos{row, 0});
                detailGrid.add(Label(sel.context.skillExecutionStartedTimestamp->toTimeString()), Pos{row, 1});
                row++;
            }
 
            if (sel.context.naturalLanguageDescription.has_value())
            {
                detailGrid.add(Label("Description"), Pos{row, 0});
                detailGrid.add(Label(truncateStr(sel.context.naturalLanguageDescription.value(), detailMaxLen)), Pos{row, 1});
                row++;
            }
 
            for (const auto& [key, value] : sel.context.parameters)
            {
                detailGrid.add(Label("Param: " + key), Pos{row, 0});
                detailGrid.add(Label(truncateStr(value, detailMaxLen)), Pos{row, 1});
                row++;
            }
 
            for (const auto& [key, value] : sel.context.additional)
            {
                detailGrid.add(Label("Extra: " + key), Pos{row, 0});
                detailGrid.add(Label(truncateStr(value, detailMaxLen)), Pos{row, 1});
                row++;
            }
 
            for (const auto& [key, value] : sel.context.taskPreconditions.items())
            {
                detailGrid.add(Label("Precond: " + key), Pos{row, 0});
                detailGrid.add(Label(truncateStr(value.dump(), detailMaxLen)), Pos{row, 1});
                row++;
            }
 
            for (const auto& [key, value] : sel.context.taskPostconditions.items())
            {
                detailGrid.add(Label("Postcond: " + key), Pos{row, 0});
                detailGrid.add(Label(truncateStr(value.dump(), detailMaxLen)), Pos{row, 1});
                row++;
            }
 
            detailGroup.addChild(detailGrid);
        }
        else
        {
            detailGroup.setLabel("Selected: (none)");
            detailGroup.addChild(Label("Click \"select\" on a row to select an outcome."));
        }
 
        // --- Right panel: Edit outcome ---
        // Always add the edit widgets to the layout so they are registered
        // with the tab. Otherwise wasClicked()/getValue() crash on
        // unregistered widgets in RemoteGui_update().
        GroupBox editGroup;
        editGroup.setLabel("Edit Outcome");
 
        const bool hasSelection = selectedOutcomeIndex >= 0 &&
                                  selectedOutcomeIndex < static_cast<int>(outcomes.size());
 
        if (selectionJustChanged)
        {
            editStatusMessage = "";
            if (hasSelection)
            {
                const auto& sel = outcomes[selectedOutcomeIndex];
                editErrorText = sel.errorMessage.value_or("");
                editStatus = outcomeTypeToString(sel.outcomeType);
                editFailureType = sel.failureInfo.has_value()
                    ? sel.failureInfo->failureType
                    : armem::task_outcome::FailureType{};
            }
            else
            {
                editErrorText = "";
                editStatus = "UNKNOWN";
                editFailureType = armem::task_outcome::FailureType{};
            }
            selectionJustChanged = false;
        }
 
        tab.statusComboBox.setOptions({"UNKNOWN", "SUCCESS", "FAILURE", "ABORTED", "SUSPENDED"});
        tab.statusComboBox.setValue(editStatus);
 
        // Set checkbox values from editFailureType
        tab.failureCheckBoxes.planningNoTrajectoryFound.setValue(editFailureType.planning.noTrajectoryFound);
        tab.failureCheckBoxes.planningNoGraspFound.setValue(editFailureType.planning.noGraspFound);
        tab.failureCheckBoxes.planningSpecial.setValue(editFailureType.planning.special);
        tab.failureCheckBoxes.perceptionObjectNotDetected.setValue(editFailureType.knowledge.perception.objectNotDetected);
        tab.failureCheckBoxes.perceptionCameraNotWorking.setValue(editFailureType.knowledge.perception.cameraNotWorking);
        tab.failureCheckBoxes.knowledgeRetrievalTechnicalFailure.setValue(editFailureType.knowledge.knowledgeRetrieval.technicalFailure);
        tab.failureCheckBoxes.knowledgeRetrievalKnowledgeNotInMemory.setValue(editFailureType.knowledge.knowledgeRetrieval.knowledgeNotInMemory);
        tab.failureCheckBoxes.executionRobotNotMoving.setValue(editFailureType.execution.robotNotMoving);
        tab.failureCheckBoxes.executionHandNotClosing.setValue(editFailureType.execution.handNotClosing);
        tab.failureCheckBoxes.executionGraspingFailureDetected.setValue(editFailureType.execution.graspingFailureDetected);
        tab.failureCheckBoxes.interactionNoHumanForHandover.setValue(editFailureType.interaction.noHumanForHandover);
        tab.failureCheckBoxes.interactionDesiredObjectNotAtLocation.setValue(editFailureType.interaction.desiredObjectNotAtLocation);
        tab.failureCheckBoxes.interactionCommunicationFailure.setValue(editFailureType.interaction.communicationFailure);
        tab.failureCheckBoxes.interruptionUserStopped.setValue(editFailureType.interruption.userStopped);
        tab.failureCheckBoxes.subskillFailureFailed.setValue(editFailureType.subskillFailure.failed);
        tab.failureCheckBoxes.subskillFailureName.setValue(editFailureType.subskillFailure.subskillName);
 
        tab.errorMessageInput.setValue(editErrorText);
        tab.saveButton.setLabel("Save");
 
        GridLayout editGrid;
        int editRow = 0;
        if (!hasSelection)
        {
            editGrid.add(Label("Select an outcome to edit."), Pos{editRow, 0});
            editRow++;
        }
        editGrid.add(Label("Status:"), Pos{editRow, 0});
        editRow++;
        editGrid.add(tab.statusComboBox, Pos{editRow, 0});
        editRow++;
 
        // Planning Failures group
        {
            GroupBox planningGroup;
            planningGroup.setLabel("Planning Failures");
            GridLayout planningGrid;
            planningGrid.add(tab.failureCheckBoxes.planningNoTrajectoryFound, Pos{0, 0});
            planningGrid.add(Label("No Trajectory Found"), Pos{0, 1});
            planningGrid.add(tab.failureCheckBoxes.planningNoGraspFound, Pos{1, 0});
            planningGrid.add(Label("No Grasp Found"), Pos{1, 1});
            planningGrid.add(tab.failureCheckBoxes.planningSpecial, Pos{2, 0});
            planningGrid.add(Label("Special"), Pos{2, 1});
            planningGroup.addChild(planningGrid);
            editGrid.add(planningGroup, Pos{editRow, 0});
            editRow++;
        }
 
        // Knowledge Failures group
        {
            GroupBox knowledgeGroup;
            knowledgeGroup.setLabel("Knowledge Failures");
            GridLayout knowledgeGrid;
            int kRow = 0;
            knowledgeGrid.add(Label("-- Perception --"), Pos{kRow, 0}, Span{1, 2});
            kRow++;
            knowledgeGrid.add(tab.failureCheckBoxes.perceptionObjectNotDetected, Pos{kRow, 0});
            knowledgeGrid.add(Label("Object Not Detected"), Pos{kRow, 1});
            kRow++;
            knowledgeGrid.add(tab.failureCheckBoxes.perceptionCameraNotWorking, Pos{kRow, 0});
            knowledgeGrid.add(Label("Camera Not Working"), Pos{kRow, 1});
            kRow++;
            knowledgeGrid.add(Label("-- Knowledge Retrieval --"), Pos{kRow, 0}, Span{1, 2});
            kRow++;
            knowledgeGrid.add(tab.failureCheckBoxes.knowledgeRetrievalTechnicalFailure, Pos{kRow, 0});
            knowledgeGrid.add(Label("Technical Failure"), Pos{kRow, 1});
            kRow++;
            knowledgeGrid.add(tab.failureCheckBoxes.knowledgeRetrievalKnowledgeNotInMemory, Pos{kRow, 0});
            knowledgeGrid.add(Label("Knowledge Not In Memory"), Pos{kRow, 1});
            knowledgeGroup.addChild(knowledgeGrid);
            editGrid.add(knowledgeGroup, Pos{editRow, 0});
            editRow++;
        }
 
        // Execution Failures group
        {
            GroupBox executionGroup;
            executionGroup.setLabel("Execution Failures");
            GridLayout executionGrid;
            executionGrid.add(tab.failureCheckBoxes.executionRobotNotMoving, Pos{0, 0});
            executionGrid.add(Label("Robot Not Moving"), Pos{0, 1});
            executionGrid.add(tab.failureCheckBoxes.executionHandNotClosing, Pos{1, 0});
            executionGrid.add(Label("Hand Not Closing"), Pos{1, 1});
            executionGrid.add(tab.failureCheckBoxes.executionGraspingFailureDetected, Pos{2, 0});
            executionGrid.add(Label("Grasping Failure Detected"), Pos{2, 1});
            executionGroup.addChild(executionGrid);
            editGrid.add(executionGroup, Pos{editRow, 0});
            editRow++;
        }
 
        // Interaction Failures group
        {
            GroupBox interactionGroup;
            interactionGroup.setLabel("Interaction Failures");
            GridLayout interactionGrid;
            interactionGrid.add(tab.failureCheckBoxes.interactionNoHumanForHandover, Pos{0, 0});
            interactionGrid.add(Label("No Human For Handover"), Pos{0, 1});
            interactionGrid.add(tab.failureCheckBoxes.interactionDesiredObjectNotAtLocation, Pos{1, 0});
            interactionGrid.add(Label("Desired Object Not At Location"), Pos{1, 1});
            interactionGrid.add(tab.failureCheckBoxes.interactionCommunicationFailure, Pos{2, 0});
            interactionGrid.add(Label("Communication Failure"), Pos{2, 1});
            interactionGroup.addChild(interactionGrid);
            editGrid.add(interactionGroup, Pos{editRow, 0});
            editRow++;
        }
 
        // Interruption Failures group
        {
            GroupBox interruptionGroup;
            interruptionGroup.setLabel("Interruption Failures");
            GridLayout interruptionGrid;
            interruptionGrid.add(tab.failureCheckBoxes.interruptionUserStopped, Pos{0, 0});
            interruptionGrid.add(Label("User Stopped"), Pos{0, 1});
            interruptionGroup.addChild(interruptionGrid);
            editGrid.add(interruptionGroup, Pos{editRow, 0});
            editRow++;
        }
 
        // Subskill Failure group
        {
            GroupBox subskillGroup;
            subskillGroup.setLabel("Subskill Failure");
            GridLayout subskillGrid;
            subskillGrid.add(tab.failureCheckBoxes.subskillFailureFailed, Pos{0, 0});
            subskillGrid.add(Label("Failed"), Pos{0, 1});
            subskillGrid.add(Label("Subskill Name:"), Pos{1, 0});
            subskillGrid.add(tab.failureCheckBoxes.subskillFailureName, Pos{1, 1});
            subskillGroup.addChild(subskillGrid);
            editGrid.add(subskillGroup, Pos{editRow, 0});
            editRow++;
        }
 
        editGrid.add(Label("Error Message:"), Pos{editRow, 0});
        editRow++;
        editGrid.add(tab.errorMessageInput, Pos{editRow, 0});
        editRow++;
        editGrid.add(tab.saveButton, Pos{editRow, 0});
        editRow++;
        const std::string messageHtml = editStatusMessage.empty()
            ? " "
            : "<font color='red'>" + editStatusMessage + "</font>";
        editGrid.add(Label(messageHtml), Pos{editRow, 0});
        editGroup.addChild(editGrid);
 
        VBoxLayout leftColumn = {settingsGroup, resultsGroup, detailGroup, VSpacer()};
        VBoxLayout rightColumn = {editGroup, VSpacer()};
        HBoxLayout root = {leftColumn, rightColumn};
        RemoteGui_createTab(getName(), root, &tab);
    }
 
    void
    TaskOutcomeMemory::RemoteGui_update()
    {
        bool needsRebuild = false;
 
        // Preserve user's input before any rebuild overwrites it.
        editErrorText = tab.errorMessageInput.getValue();
        editStatus = tab.statusComboBox.getValue();
        editFailureType.planning.noTrajectoryFound = tab.failureCheckBoxes.planningNoTrajectoryFound.getValue();
        editFailureType.planning.noGraspFound = tab.failureCheckBoxes.planningNoGraspFound.getValue();
        editFailureType.planning.special = tab.failureCheckBoxes.planningSpecial.getValue();
        editFailureType.knowledge.perception.objectNotDetected = tab.failureCheckBoxes.perceptionObjectNotDetected.getValue();
        editFailureType.knowledge.perception.cameraNotWorking = tab.failureCheckBoxes.perceptionCameraNotWorking.getValue();
        editFailureType.knowledge.knowledgeRetrieval.technicalFailure = tab.failureCheckBoxes.knowledgeRetrievalTechnicalFailure.getValue();
        editFailureType.knowledge.knowledgeRetrieval.knowledgeNotInMemory = tab.failureCheckBoxes.knowledgeRetrievalKnowledgeNotInMemory.getValue();
        editFailureType.execution.robotNotMoving = tab.failureCheckBoxes.executionRobotNotMoving.getValue();
        editFailureType.execution.handNotClosing = tab.failureCheckBoxes.executionHandNotClosing.getValue();
        editFailureType.execution.graspingFailureDetected = tab.failureCheckBoxes.executionGraspingFailureDetected.getValue();
        editFailureType.interaction.noHumanForHandover = tab.failureCheckBoxes.interactionNoHumanForHandover.getValue();
        editFailureType.interaction.desiredObjectNotAtLocation = tab.failureCheckBoxes.interactionDesiredObjectNotAtLocation.getValue();
        editFailureType.interaction.communicationFailure = tab.failureCheckBoxes.interactionCommunicationFailure.getValue();
        editFailureType.interruption.userStopped = tab.failureCheckBoxes.interruptionUserStopped.getValue();
        editFailureType.subskillFailure.failed = tab.failureCheckBoxes.subskillFailureFailed.getValue();
        editFailureType.subskillFailure.subskillName = tab.failureCheckBoxes.subskillFailureName.getValue();
 
        if (tab.maxEntries.hasValueChanged())
        {
            guiMaxEntries = tab.maxEntries.getValue();
            needsRebuild = true;
        }
 
        // Handle selection: if a toggle button was clicked, select that row.
        for (auto& [index, btn] : tab.selectButtons)
        {
            if (btn.hasValueChanged() && btn.getValue())
            {
                selectedOutcomeIndex = index;
                selectionJustChanged = true;
                needsRebuild = true;
            }
            else if (btn.hasValueChanged() && !btn.getValue() &&
                     index == selectedOutcomeIndex)
            {
                selectedOutcomeIndex = -1;
                selectionJustChanged = true;
                needsRebuild = true;
            }
        }
 
        // Handle save button.
        if (tab.saveButton.wasClicked() && selectedOutcomeIndex >= 0 &&
            selectedOutcomeIndex < static_cast<int>(displayedOutcomeIds.size()))
        {
            const std::string newError = tab.errorMessageInput.getValue();
            const std::string newStatus = tab.statusComboBox.getValue();
            const auto& id = displayedOutcomeIds[selectedOutcomeIndex];
 
            const auto newOutcomeType = stringToOutcomeType(newStatus);
 
            editStatusMessage = "";
 
            try
            {
                auto& instance = workingMemory()
                                     .getCoreSegment(id.coreSegmentName)
                                     .getProviderSegment(id.providerSegmentName)
                                     .getEntity(id.entityName)
                                     .getSnapshot(id.timestamp)
                                     .getInstance(id.instanceIndex);
 
                auto dto = armarx::task_outcome::arondto::TaskOutcome::FromAron(
                    instance.data());
 
                // Update error message.
                dto.errorMessage = newError.empty()
                                       ? std::optional<std::string>(std::nullopt)
                                       : std::optional<std::string>(newError);
 
                // Update outcome type (status).
                armem::task_outcome::toAron(dto.outcomeType, newOutcomeType);
 
                // Update failure info.
                if (!dto.failureInfo.has_value())
                {
                    armarx::task_outcome::arondto::FailureInfo fi;
                    armem::task_outcome::FailureType defaultFt;
                    armem::task_outcome::toAron(fi.failureType, defaultFt);
                    dto.failureInfo = fi;
                }
                armem::task_outcome::toAron(dto.failureInfo->failureType, editFailureType);
 
                instance.data() = dto.toAron();
 
                ARMARX_INFO << "Updated outcome for '" << id.entityName
                            << "': status=" << newStatus
                            << ", failures=" << failureTypeSummary(editFailureType)
                            << ", error='" << newError << "'";
            }
            catch (const std::exception& e)
            {
                ARMARX_WARNING << "Failed to update outcome: " << e.what();
            }
 
            needsRebuild = true;
        }
 
        // Rebuild when new data was committed (only when not editing).
        if (selectedOutcomeIndex < 0 && newDataAvailable.exchange(false))
        {
            needsRebuild = true;
        }
 
        if (needsRebuild)
        {
            createRemoteGuiTab();
        }
    }
 
} // namespace armarx