Step 568: integrate phase 31a memory reflection workflow

editor/src/Phase31aIntegration.h

@@ -0,0 +1,156 @@
+#pragma once
+// Step 568: Phase 31a Integration
+
+#include "AllocationOwnershipTraceHooks.h"
+#include "CallStackFrameInspector.h"
+#include "DebugSessionModel.h"
+#include "LeakCorruptionSignalBridge.h"
+#include "MemoryInspectorUiModel.h"
+#include "MemorySnapshotModel.h"
+
+#include <algorithm>
+#include <string>
+#include <vector>
+
+struct Phase31aInput {
+    std::string sessionId = "session-31a";
+    std::string snapshotId = "snapshot-31a";
+    std::string threadId = "thread-main";
+    std::string targetId = "target-main";
+    std::string bufferId = "buffer-main";
+    std::string executablePath = "/tmp/whetstone-app";
+
+    std::string stackRegionId = "stack-region";
+    std::string heapRegionId = "heap-region";
+    std::string pointerText = "0x2008";
+
+    std::string allocationId = "alloc-main";
+    std::string signalAllocationId = "";
+    std::string initialOwner = "runtime";
+    std::string transferredOwner = "inspector";
+
+    std::string frameFunction = "run";
+    std::string frameFile = "src/main.ws";
+    int frameLine = 42;
+    bool emitCorruptionSignal = false;
+    bool omitSignalMessage = false;
+};
+
+struct Phase31aResult {
+    bool snapshotReady = false;
+    bool inspectorReady = false;
+    bool traceReady = false;
+    bool signalBridgeReady = false;
+    bool stackCorrelationReady = false;
+    bool phase31aPass = false;
+    MemorySignalSeverity maxSeverity = MemorySignalSeverity::Info;
+    std::vector<std::string> notes;
+};
+
+class Phase31aIntegration {
+public:
+    static Phase31aResult run(const Phase31aInput& input) {
+        Phase31aResult result;
+        MemorySnapshot snapshot;
+        std::string error;
+
+        DebugSessionModel debugSession;
+        if (!debugSession.start(input.targetId, input.bufferId, input.executablePath)) {
+            result.notes.push_back("fail:debug_session_start");
+            return finalize(result);
+        }
+
+        if (!MemorySnapshotModel::createSnapshot(input.snapshotId,
+                                                 input.sessionId,
+                                                 input.threadId,
+                                                 1,
+                                                 &snapshot,
+                                                 &error)) {
+            result.notes.push_back("fail:snapshot_create");
+            return finalize(result);
+        }
+        if (!MemorySnapshotModel::addRegion(&snapshot, {input.stackRegionId, MemoryRegionKind::Stack, 0x1000, 0x100, false}, &error) ||
+            !MemorySnapshotModel::addRegion(&snapshot, {input.heapRegionId, MemoryRegionKind::Heap, 0x2000, 0x100, false}, &error) ||
+            !MemorySnapshotModel::addReference(&snapshot, {0x1010, 0x2008, "stack_ptr"}, &error)) {
+            result.notes.push_back("fail:snapshot_content");
+            return finalize(result);
+        }
+        result.snapshotReady = true;
+
+        MemoryValueNode root;
+        MemoryValueNode pointerNode;
+        if (!MemoryInspectorUiModel::createComposite("root", "Memory", MemoryValueKind::Struct, &root, &error) ||
+            !MemoryInspectorUiModel::createLeaf("ptr", "head", MemoryValueKind::Pointer, input.pointerText, &pointerNode, &error) ||
+            !MemoryInspectorUiModel::appendChild(&root, pointerNode, &error)) {
+            result.notes.push_back("fail:inspector_node_build");
+            return finalize(result);
+        }
+        const auto rows = MemoryInspectorUiModel::collectVisibleRows(root, 8);
+        const MemoryRegionRecord* pointerRegion = nullptr;
+        if (rows.size() < 2 ||
+            !MemoryInspectorUiModel::resolvePointerRegion(snapshot, pointerNode, &pointerRegion, &error) ||
+            !pointerRegion) {
+            result.notes.push_back("fail:inspector_pointer_resolve");
+            return finalize(result);
+        }
+        result.inspectorReady = true;
+
+        AllocationOwnershipTraceHooks hooks;
+        if (!hooks.recordAllocation(input.sessionId, input.allocationId, 0x2008, 64, input.initialOwner, 10, &error) ||
+            !hooks.transferOwnership(input.sessionId, input.allocationId, input.transferredOwner, 20, &error)) {
+            result.notes.push_back("fail:allocation_trace");
+            return finalize(result);
+        }
+        result.traceReady = hooks.ownerFor(input.allocationId) == input.transferredOwner;
+        if (!result.traceReady) {
+            result.notes.push_back("fail:allocation_owner_mismatch");
+            return finalize(result);
+        }
+
+        LeakCorruptionSignalBridge bridge;
+        const std::string signalAllocId = input.signalAllocationId.empty() ? input.allocationId : input.signalAllocationId;
+        const std::string leakMessage = input.omitSignalMessage ? "" : "Potential leak near allocation";
+        if (!bridge.ingestSignal({"sig-1", input.sessionId, signalAllocId, MemorySignalType::LeakSuspected,
+                                  leakMessage, 30}, &error)) {
+            result.notes.push_back("fail:signal_bridge_ingest");
+            return finalize(result);
+        }
+        if (input.emitCorruptionSignal &&
+            !bridge.ingestSignal({"sig-2", input.sessionId, signalAllocId, MemorySignalType::CorruptionConfirmed,
+                                  "Corruption confirmed near allocation", 31}, &error)) {
+            result.notes.push_back("fail:signal_bridge_corruption_ingest");
+            return finalize(result);
+        }
+        result.signalBridgeReady = !bridge.diagnosticsForSession(input.sessionId).empty();
+        result.maxSeverity = bridge.highestSeverityForSession(input.sessionId);
+
+        FrameScope frame;
+        frame.frameIndex = 0;
+        frame.functionName = input.frameFunction;
+        frame.filePath = input.frameFile;
+        frame.line = input.frameLine;
+        frame.variables["ptr"] = input.pointerText;
+        const auto frameResult = CallStackFrameInspector::inspect({frame}, 0);
+        const auto vars = CallStackFrameInspector::variableNames(frame);
+        const bool hasPointerVar = std::find(vars.begin(), vars.end(), "ptr") != vars.end();
+        result.stackCorrelationReady = frameResult.ok && hasPointerVar && debugSession.hasTargetForBuffer(input.bufferId);
+        if (!result.stackCorrelationReady) {
+            result.notes.push_back("fail:stack_correlation");
+            return finalize(result);
+        }
+
+        result.notes.push_back("phase31a:memory_reflection_cycle_ready");
+        return finalize(result);
+    }
+
+private:
+    static Phase31aResult finalize(Phase31aResult result) {
+        result.phase31aPass = result.snapshotReady &&
+                             result.inspectorReady &&
+                             result.traceReady &&
+                             result.signalBridgeReady &&
+                             result.stackCorrelationReady;
+        if (!result.phase31aPass) result.notes.push_back("phase31a:blocked");
+        return result;
+    }
+};