outfit: a skill is a .md file; form: terminal comes out

The loader read every file in the skills directory and named it by chopping
its last suffix. filepath.Ext("howto.md.pre-bundle-20260629") is
".pre-bundle-20260629", so a backup left beside the real howto loaded as a
skill called "howto.md". Any stray .bak or .swp did the same, under whatever
name the chop produced.

That invented collision is what node.terminal existed to preserve: provenance
threaded through the tree, the diff and the wire so skills.howto.md could sit
beside skills.howto rather than inside it. With the loader fixed the case does
not arise, and the guard is again what it should be -- a leaf stands where a
branch is wanted, so the rest of the key stays whole beside it.

succession is the real prefix collision and needs no provenance: its value is
prose, so it is a leaf and the guard fires.

115 lines removed.

The fixture carried the invented skill; it is regenerated without it.

Author: gluck

api/form/form.go

@@ -229,12 +229,6 @@ func diffTrees(prev, next ptree) Patch {
 						out.New = map[string]bool{}
 					}
 					out.Update[n.key], out.New[n.key] = child, true
-					if n.terminal {
-						if out.Term == nil {
-							out.Term = map[string]bool{}
-						}
-						out.Term[n.key] = true
-					}
 				}
 				return true
 			}
@@ -249,12 +243,6 @@ func diffTrees(prev, next ptree) Patch {
 					out.Update = map[string]Patch{}
 				}
 				out.Update[n.key] = child
-				if n.terminal {
-					if out.Term == nil {
-						out.Term = map[string]bool{}
-					}
-					out.Term[n.key] = true
-				}
 			}
 		case !old.branch && !n.branch:
 			if !old.value.Equal(n.value) {
@@ -337,9 +325,7 @@ func applyToTree(t ptree, p Patch) (ptree, bool) {
 		if cur := lookupExact(t.root, k); cur != nil && !cur.branch && cur.value.Equal(v) {
 			continue
 		}
-		e := leafOrBranch(k, v)
-		e.terminal = true
-		t = ptree{root: setEntry(t.root, e)}
+		t = ptree{root: setEntry(t.root, leafOrBranch(k, v))}
 		changed = true
 	}
 	for k := range p.Object.Delete {
@@ -349,22 +335,6 @@ func applyToTree(t ptree, p Patch) (ptree, bool) {
 	}
 	for k, child := range p.Object.Update {
 		cur := lookupExact(t.root, k)
-		if cur != nil && cur.terminal {
-			// The key ends here for whoever wrote it, so a patch that would
-			// reach through it is naming siblings rather than fields. A flat
-			// patch has no base and cannot know that when it splits its keys.
-			// Only a suffix the node does not already hold is a sibling.
-			// A field it does hold is an edit of that field.
-			if flat, ok := flattenUnder(child); ok && allForeign(cur, flat) {
-				for suffix, v := range flat {
-					e := leafOrBranch(k+"."+suffix, v)
-					e.terminal = true
-					t = ptree{root: setEntry(t.root, e)}
-					changed = true
-				}
-				continue
-			}
-		}
 		var kids ptree
 		leafHere := cur != nil && !cur.branch
 		if cur != nil && cur.branch {
@@ -383,8 +353,7 @@ func applyToTree(t ptree, p Patch) (ptree, bool) {
 		if !subChanged && cur != nil {
 			continue
 		}
-		term := p.Object.Term[k] || (cur != nil && cur.terminal)
-		t = ptree{root: setEntry(t.root, &node{key: k, kids: sub, branch: true, terminal: term})}
+		t = ptree{root: setEntry(t.root, &node{key: k, kids: sub, branch: true})}
 		changed = true
 	}
 	return t, changed
@@ -652,67 +621,3 @@ func setIn(node Value, segs []string, v Value) Value {
 
 // flattenUnder reads a patch that only creates leaves as the suffixes it
 // names, so they can be written beside a terminal node rather than inside it.
-// It refuses anything that changes or removes: only a pure creation can be
-// re-anchored without knowing what it was diffed against.
-func flattenUnder(p Patch) (map[string]Value, bool) {
-	out := map[string]Value{}
-	var walk func(Patch, string) bool
-	walk = func(q Patch, prefix string) bool {
-		if q.Object == nil {
-			return false
-		}
-		if len(q.Object.Delete) > 0 {
-			return false
-		}
-		for k, v := range q.Object.Set {
-			out[join(prefix, k)] = v
-		}
-		for k, c := range q.Object.Update {
-			if !q.Object.New[k] {
-				return false
-			}
-			if !walk(c, join(prefix, k)) {
-				return false
-			}
-		}
-		return true
-	}
-	if !walk(p, "") || len(out) == 0 {
-		return nil, false
-	}
-	return out, true
-}
-
-func join(prefix, k string) string {
-	if prefix == "" {
-		return k
-	}
-	return prefix + "." + k
-}
-
-// allForeign reports whether every suffix names something the node does not
-// hold. One that it holds is a field, and the patch is editing it.
-func allForeign(n *node, flat map[string]Value) bool {
-	if n == nil || !n.branch {
-		return false
-	}
-	for suffix := range flat {
-		head := suffix
-		if i := indexDot(suffix); i >= 0 {
-			head = suffix[:i]
-		}
-		if lookupExact(n.kids.root, head) != nil {
-			return false
-		}
-	}
-	return true
-}
-
-func indexDot(s string) int {
-	for i := 0; i < len(s); i++ {
-		if s[i] == '.' {
-			return i
-		}
-	}
-	return -1
-}

api/form/patch.go

@@ -36,11 +36,6 @@ type ObjectPatch struct {
 	Delete map[string]Value `json:"Delete,omitempty"`
 	Update map[string]Patch `json:"Update,omitempty"`
 
-	// Term names the Update keys where a caller's key ENDED. Splitting a
-	// dotted key into segments loses that, and without it a later key
-	// reaches through the node instead of landing beside it.
-	Term map[string]bool `json:"Term,omitempty"`
-
 	// New names the Update keys that did not exist. Their leaves are
 	// described rather than the subtree, so two patches adding different
 	// fields under one parent compose; the flag is what lets Inverse remove

api/form/regression_test.go

@@ -17,17 +17,17 @@ import (
 // its prefix. Gluck's store holds both: skills.howto is a skill, and
 // skills.howto.md is a different skill.
 func TestCollidingKeysAreBothAddressable(t *testing.T) {
+	// succession is prose AND a namespace of sub-notes: a key that is a
+	// proper prefix of another, written deliberately.
 	s := form.FromMap(map[string]json.RawMessage{
-		"skills.howto":    json.RawMessage(`{"filePath":"/a.md"}`),
-		"skills.howto.md": json.RawMessage(`{"filePath":"/b.md"}`),
-		"succession":      json.RawMessage(`["one"]`),
-		"succession.plan": json.RawMessage(`"handover"`),
+		"succession":           json.RawMessage(`"the protocol"`),
+		"succession.rule":      json.RawMessage(`"you are a seat"`),
+		"succession.authority": json.RawMessage(`"only the target may write"`),
 	})
 	for k, want := range map[string]string{
-		"skills.howto":    `{"filePath":"/a.md"}`,
-		"skills.howto.md": `{"filePath":"/b.md"}`,
-		"succession":      `["one"]`,
-		"succession.plan": `"handover"`,
+		"succession":           `"the protocol"`,
+		"succession.rule":      `"you are a seat"`,
+		"succession.authority": `"only the target may write"`,
 	} {
 		got, ok := s.Get(k)
 		require.True(t, ok, "%s is unreachable", k)

api/form/succession_test.go

@@ -0,0 +1,38 @@
+package form_test
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/jack-work/figaro/api/form"
+)
+
+// A key that is a proper prefix of another, written deliberately: succession
+// is prose AND a namespace of sub-notes.
+func TestParentAndChildKeysBothSurvive(t *testing.T) {
+	src := map[string]json.RawMessage{
+		"succession":           json.RawMessage(`"the protocol"`),
+		"succession.rule":      json.RawMessage(`"you are a seat"`),
+		"succession.authority": json.RawMessage(`"only the target may write"`),
+	}
+	s := form.FromMap(src)
+	for k, want := range src {
+		got, ok := s.Get(k)
+		require.True(t, ok, "%s unreachable", k)
+		assert.JSONEq(t, string(want), string(got), k)
+	}
+
+	// And across a reload, which is where the shape has to agree with itself.
+	raw, err := json.Marshal(s)
+	require.NoError(t, err)
+	var back form.Snapshot
+	require.NoError(t, json.Unmarshal(raw, &back))
+	for k, want := range src {
+		got, ok := back.Get(k)
+		require.True(t, ok, "%s did not survive a reload", k)
+		assert.JSONEq(t, string(want), string(got), k)
+	}
+}