Merge branch 'worktree-self-improving-loops'

Author: scgopi

GraphcodeKit/Sources/Domain/LoopNode.swift

@@ -55,6 +55,12 @@ public struct LoopNode: Identifiable, Codable, Equatable, Sendable {
   /// full unbounded series lives in the node's memory log; this is the cache the canvas
   /// and the plateau rule read.
   public var metricHistory: [MetricSample]
+  /// The loop that asked for this one, when a running session created it through the
+  /// CLI (`NodeDraft.createdBy`). Recorded on the node, not just as the already-fired
+  /// edge `linkToCreator` draws — a fired edge is indistinguishable from any drawn
+  /// handoff, and custody has to be: stopping or deleting a parent takes its spawned
+  /// descendants with it, while a drawn edge to a peer must never be caught in that.
+  public let createdBy: UUID?
   public var state: LoopState
   public var createdAt: Date
 
@@ -72,6 +78,7 @@ public struct LoopNode: Identifiable, Codable, Equatable, Sendable {
     pilotState: PilotState = .notPiloted,
     usage: UsageSample? = nil,
     metricHistory: [MetricSample] = [],
+    createdBy: UUID? = nil,
     state: LoopState = .idle,
     createdAt: Date = Date()
   ) {
@@ -88,6 +95,7 @@ public struct LoopNode: Identifiable, Codable, Equatable, Sendable {
     self.pilotState = pilotState
     self.usage = usage
     self.metricHistory = metricHistory
+    self.createdBy = createdBy
     self.state = state
     self.createdAt = createdAt
   }
@@ -164,7 +172,8 @@ public struct LoopNode: Identifiable, Codable, Equatable, Sendable {
 
   private enum CodingKeys: String, CodingKey {
     case id, title, loopType, checkDescription, triggerPrompt, goal, backend, modelTier
-    case worktreeBinding, subGraph, pilotState, usage, metricHistory, state, createdAt
+    case worktreeBinding, subGraph, pilotState, usage, metricHistory, createdBy
+    case state, createdAt
   }
 
   /// Hand-written for the same reason `LoopEdge`'s is: `ProjectPersistence.loadGraph`
@@ -187,6 +196,7 @@ public struct LoopNode: Identifiable, Codable, Equatable, Sendable {
     usage = try container.decodeIfPresent(UsageSample.self, forKey: .usage)
     metricHistory =
       try container.decodeIfPresent([MetricSample].self, forKey: .metricHistory) ?? []
+    createdBy = try container.decodeIfPresent(UUID.self, forKey: .createdBy)
     state = try container.decodeIfPresent(LoopState.self, forKey: .state) ?? .idle
     createdAt = try container.decodeIfPresent(Date.self, forKey: .createdAt) ?? Date()
   }

GraphcodeKit/Sources/Domain/NodeDraft.swift

@@ -160,6 +160,7 @@ public struct NodeDraft: Codable, Equatable, Sendable {
           ?? LoopGraph(
             project: ProjectRef(path: "\(resolvedTitle)-subgraph", name: resolvedTitle)))
         : nil,
+      createdBy: createdBy,
       state: loopType == .goalBased ? .running : .idle)
   }
 }

GraphcodeKit/Sources/GraphStore.swift

@@ -508,11 +508,21 @@ public actor GraphStore {
   /// re-evaluated afterwards for exactly that reason.
   private func deleteNode(_ nodeID: UUID) {
     guard let node = graph.nodes[id: nodeID] else { return }
+    // Children go with the parent: deleting a coordinator must not strand the workers
+    // it fanned out, still running against a plan nobody owns anymore. Custody comes
+    // from `createdBy`, never from edges — a drawn handoff to a peer is a
+    // relationship, not ownership, and stays out of the blast radius.
+    for child in spawnedDescendants(of: nodeID) {
+      removeSingleNode(child)
+    }
+    removeSingleNode(node)
+  }
 
-    let downstream = Set(graph.edges.filter { $0.from == nodeID }.map(\.to))
-    graph.edges.removeAll { $0.from == nodeID || $0.to == nodeID }
-    graph.nodes.remove(id: nodeID)
-    cancelGoalPoller(nodeID)
+  private func removeSingleNode(_ node: LoopNode) {
+    let downstream = Set(graph.edges.filter { $0.from == node.id }.map(\.to))
+    graph.edges.removeAll { $0.from == node.id || $0.to == node.id }
+    graph.nodes.remove(id: node.id)
+    cancelGoalPoller(node.id)
     for targetID in downstream {
       unblockIfStillIdle(targetID)
     }
@@ -524,6 +534,22 @@ public actor GraphStore {
     onRemoveMemory?(node.id)
   }
 
+  /// The fan-out descendants of a node — the loops it created, theirs, and so on,
+  /// walked through `LoopNode.createdBy`.
+  private func spawnedDescendants(of nodeID: UUID) -> [LoopNode] {
+    var found: [LoopNode] = []
+    var queue = [nodeID]
+    var visited: Set<UUID> = [nodeID]
+    while let current = queue.popLast() {
+      for node in graph.nodes
+      where node.createdBy == current && visited.insert(node.id).inserted {
+        found.append(node)
+        queue.append(node.id)
+      }
+    }
+    return found
+  }
+
   /// The stop/kill affordance from docs/05-orchestrator.md#monitoring-surface — "a
   /// proactive routine runs until you turn it off", so there has to be an off.
   ///
@@ -537,6 +563,17 @@ public actor GraphStore {
     recordMemory(nodeID, "stopped by request")
     onTerminateSession?(node)
     fireOutgoingEdges(from: nodeID, sourceSucceeded: false)
+
+    // A stopped coordinator must not leave the workers it fanned out running headless.
+    // Custody (`createdBy`), not edges: stopping one side of a drawn maker→critic pair
+    // must not stop the other. Already-resolved children are left as they ended.
+    for child in spawnedDescendants(of: nodeID) where !child.isResolved {
+      graph.nodes[id: child.id]?.state = .stopped
+      cancelGoalPoller(child.id)
+      recordMemory(child.id, "stopped with \(node.title), which created this loop")
+      onTerminateSession?(child)
+      fireOutgoingEdges(from: child.id, sourceSucceeded: false)
+    }
   }
 
   private func deleteEdge(_ edgeID: UUID) {

graphcode/Tests/CreatedByLoopTests.swift

@@ -76,6 +76,56 @@ struct CreatedByLoopTests {
     #expect(staged[0].entry.contains("task done: report attached"))
   }
 
+  @Test
+  func stoppingAParentStopsItsSpawnedDescendantsButNotPeers() async throws {
+    // A stopped coordinator must not leave the workers it fanned out running headless —
+    // and a drawn edge to a peer is a relationship, not custody, so the peer survives.
+    let terminated = LockIsolated<[String]>([])
+    let store = GraphStore(
+      onTerminateSession: { node in terminated.withValue { $0.append(node.title) } })
+    await store.handle(.createNode(draft("parent", createdBy: nil)))
+    let parentID = try #require(await store.graph.nodes.first?.id)
+    await store.handle(.createNode(draft("child", createdBy: parentID)))
+    let childID = try #require(await store.graph.nodes.first { $0.title == "child" }?.id)
+    await store.handle(.createNode(draft("grandchild", createdBy: childID)))
+    await store.handle(.createNode(draft("peer", createdBy: nil)))
+    let peerID = try #require(await store.graph.nodes.first { $0.title == "peer" }?.id)
+    await store.handle(.createEdge(from: parentID, to: peerID, spec: EdgeSpec()))
+
+    await store.handle(.stopNode(parentID))
+
+    let graph = await store.graph
+    #expect(graph.nodes[id: parentID]?.state == .stopped)
+    #expect(graph.nodes[id: childID]?.state == .stopped)
+    #expect(graph.nodes.first { $0.title == "grandchild" }?.state == .stopped)
+    #expect(graph.nodes[id: peerID]?.state != .stopped)
+    #expect(Set(terminated.value) == ["parent", "child", "grandchild"])
+  }
+
+  @Test
+  func deletingAParentDeletesItsSpawnedDescendants() async throws {
+    // Deleting a coordinator takes its fan-out tree — sessions, edges, memory — while
+    // an ordinary peer connected by a drawn edge stays in the graph.
+    let removedMemory = LockIsolated<[UUID]>([])
+    let store = GraphStore(
+      onRemoveMemory: { nodeID in removedMemory.withValue { $0.append(nodeID) } })
+    await store.handle(.createNode(draft("parent", createdBy: nil)))
+    let parentID = try #require(await store.graph.nodes.first?.id)
+    await store.handle(.createNode(draft("child", createdBy: parentID)))
+    let childID = try #require(await store.graph.nodes.first { $0.title == "child" }?.id)
+    await store.handle(.createNode(draft("peer", createdBy: nil)))
+    let peerID = try #require(await store.graph.nodes.first { $0.title == "peer" }?.id)
+
+    await store.handle(.deleteNode(parentID))
+
+    let graph = await store.graph
+    #expect(graph.nodes[id: parentID] == nil)
+    #expect(graph.nodes[id: childID] == nil)
+    #expect(graph.nodes[id: peerID] != nil)
+    #expect(graph.edges.isEmpty)
+    #expect(Set(removedMemory.value) == [parentID, childID])
+  }
+
   @Test
   func aChildInheritsItsCreatorsBackend() async throws {
     // A Copilot loop fanning work out must produce Copilot loops. The CLI used to