refactor: unify tags and edges into single rels table

cmd/add.go

@@ -26,18 +26,22 @@ var addCmd = &cobra.Command{
 			Title:   args[0],
 			Content: cContent,
 			DueDate: cDue,
-			Tags:    append([]string{}, cTags...),
 		}
 
-		// Shorthand flags expand to tags or rels.
+		// --tag is an alias for --rel with no target.
+		for _, tag := range cTags {
+			input.Rels = append(input.Rels, service.RelInput{Type: models.RelType(tag), Target: ""})
+		}
+
+		// Shorthand flags expand to property rels or edge rels.
 		if cType != "" {
-			input.Tags = append(input.Tags, "_type::"+cType)
+			input.Rels = append(input.Rels, service.RelInput{Type: models.RelType("_type::" + cType), Target: ""})
 		}
 		if cStatus != "" {
-			input.Tags = append(input.Tags, "_status::"+cStatus)
+			input.Rels = append(input.Rels, service.RelInput{Type: models.RelType("_status::" + cStatus), Target: ""})
 		}
 		if cPrio != "" {
-			input.Tags = append(input.Tags, "_prio::"+cPrio)
+			input.Rels = append(input.Rels, service.RelInput{Type: models.RelType("_prio::" + cPrio), Target: ""})
 		}
 		if cNamespace != "" {
 			input.Rels = append(input.Rels, service.RelInput{Type: models.RelInNamespace, Target: cNamespace})
@@ -75,6 +79,6 @@ func init() {
 	f.StringVar(&cAssignee, "assignee", "", "assignee username or ID")
 	f.StringVar(&cDue, "due", "", "due date")
 	f.StringVar(&cContent, "content", "", "node body")
-	f.StringArrayVar(&cTags, "tag", nil, "custom tags")
+	f.StringArrayVar(&cTags, "tag", nil, "label tag (alias for --rel tagname)")
-	f.StringArrayVar(&cRels, "rel", nil, "additional relations (type:target)")
+	f.StringArrayVar(&cRels, "rel", nil, "relation (prefix::value or relname:target)")
 }

cmd/list.go

@@ -22,19 +22,22 @@ var listCmd = &cobra.Command{
 			return
 		}
 
-		filter := service.ListFilter{
+		var filter service.ListFilter
-			Tags: append([]string{}, lTags...),
+
+		// --tag is an alias for a label filter with no target.
+		for _, tag := range lTags {
+			filter.Rels = append(filter.Rels, service.RelInput{Type: models.RelType(tag), Target: ""})
 		}
 
-		// Shorthand flags expand to tag prefixes or rel filters.
+		// Shorthand flags expand to property filters or edge filters.
 		if lStatus != "" {
-			filter.Tags = append(filter.Tags, "_status::"+lStatus)
+			filter.Rels = append(filter.Rels, service.RelInput{Type: models.RelType("_status::" + lStatus), Target: ""})
 		}
 		if lPrio != "" {
-			filter.Tags = append(filter.Tags, "_prio::"+lPrio)
+			filter.Rels = append(filter.Rels, service.RelInput{Type: models.RelType("_prio::" + lPrio), Target: ""})
 		}
 		if lType != "" {
-			filter.Tags = append(filter.Tags, "_type::"+lType)
+			filter.Rels = append(filter.Rels, service.RelInput{Type: models.RelType("_type::" + lType), Target: ""})
 		}
 		if lNamespace != "" {
 			filter.Rels = append(filter.Rels, service.RelInput{Type: models.RelInNamespace, Target: lNamespace})
@@ -66,8 +69,8 @@ var listCmd = &cobra.Command{
 func init() {
 	rootCmd.AddCommand(listCmd)
 	f := listCmd.Flags()
-	f.StringArrayVar(&lTags, "tag", nil, "filter by tag")
+	f.StringArrayVar(&lTags, "tag", nil, "filter by label tag")
-	f.StringArrayVar(&lRels, "rel", nil, "filter by relation (type:target)")
+	f.StringArrayVar(&lRels, "rel", nil, "filter by relation (prefix::value or relname:target)")
 	f.StringVar(&lStatus, "status", "", "filter by status")
 	f.StringVar(&lPrio, "prio", "", "filter by priority")
 	f.StringVar(&lType, "type", "", "filter by type")

cmd/rel.go

@@ -3,14 +3,24 @@ package cmd
 import (
 	"axolotl/models"
 	"axolotl/service"
-	"fmt"
 	"strings"
 )
 
-// parseRelInput parses a "type:target" string into a RelInput.
+// parseRelInput parses a rel string into a RelInput.
+//
+// Formats:
+//   - "prefix::value"  → property rel with no target (tag)
+//   - "relname:target" → edge rel with a target node
+//   - "tagname"        → simple label rel with no target (alias for --tag)
 func parseRelInput(s string) (service.RelInput, error) {
-	if p := strings.SplitN(s, ":", 2); len(p) == 2 {
+	if strings.Contains(s, "::") {
-		return service.RelInput{Type: models.RelType(p[0]), Target: p[1]}, nil
+		// Property: name::value — no target node.
+		return service.RelInput{Type: models.RelType(s), Target: ""}, nil
 	}
-	return service.RelInput{}, fmt.Errorf("invalid relation format: %s (expected type:target)", s)
+	if idx := strings.Index(s, ":"); idx >= 0 {
+		// Edge rel: relname:target.
+		return service.RelInput{Type: models.RelType(s[:idx]), Target: s[idx+1:]}, nil
+	}
+	// Simple label tag — no target node.
+	return service.RelInput{Type: models.RelType(s), Target: ""}, nil
 }

cmd/update.go

@@ -27,10 +27,7 @@ var updateCmd = &cobra.Command{
 			return
 		}
 
-		input := service.UpdateInput{
+		var input service.UpdateInput
-			AddTags:    append([]string{}, uAddTags...),
-			RemoveTags: uRmTags,
-		}
 
 		if cmd.Flags().Changed("title") {
 			input.Title = &uTitle
@@ -46,15 +43,23 @@ var updateCmd = &cobra.Command{
 			input.DueDate = &empty
 		}
 
-		// Shorthand flags expand to tags or rels.
+		// --tag / --tag-remove are aliases for --rel / --rel-remove with no target.
+		for _, tag := range uAddTags {
+			input.AddRels = append(input.AddRels, service.RelInput{Type: models.RelType(tag), Target: ""})
+		}
+		for _, tag := range uRmTags {
+			input.RemoveRels = append(input.RemoveRels, service.RelInput{Type: models.RelType(tag), Target: ""})
+		}
+
+		// Shorthand flags expand to property rels or edge rels.
 		if cmd.Flags().Changed("type") {
-			input.AddTags = append(input.AddTags, "_type::"+uType)
+			input.AddRels = append(input.AddRels, service.RelInput{Type: models.RelType("_type::" + uType), Target: ""})
 		}
 		if cmd.Flags().Changed("status") {
-			input.AddTags = append(input.AddTags, "_status::"+uStatus)
+			input.AddRels = append(input.AddRels, service.RelInput{Type: models.RelType("_status::" + uStatus), Target: ""})
 		}
 		if cmd.Flags().Changed("prio") {
-			input.AddTags = append(input.AddTags, "_prio::"+uPrio)
+			input.AddRels = append(input.AddRels, service.RelInput{Type: models.RelType("_prio::" + uPrio), Target: ""})
 		}
 		if cmd.Flags().Changed("namespace") {
 			input.AddRels = append(input.AddRels, service.RelInput{Type: models.RelInNamespace, Target: uNamespace})
@@ -101,8 +106,8 @@ func init() {
 	f.StringVar(&uType, "type", "", "node type")
 	f.StringVar(&uNamespace, "namespace", "", "namespace name or ID")
 	f.StringVar(&uAssignee, "assignee", "", "assignee username or ID")
-	f.StringArrayVar(&uAddTags, "tag", nil, "add tags")
+	f.StringArrayVar(&uAddTags, "tag", nil, "add label tag (alias for --rel tagname)")
-	f.StringArrayVar(&uRmTags, "tag-remove", nil, "remove tags")
+	f.StringArrayVar(&uRmTags, "tag-remove", nil, "remove label tag")
-	f.StringArrayVar(&uAddRels, "rel", nil, "add relations (type:target)")
+	f.StringArrayVar(&uAddRels, "rel", nil, "add relation (prefix::value or relname:target)")
-	f.StringArrayVar(&uRmRels, "rel-remove", nil, "remove relations (type:target)")
+	f.StringArrayVar(&uRmRels, "rel-remove", nil, "remove relation (prefix::value or relname:target)")
 }

models/node.go

@@ -5,8 +5,6 @@ import (
 	"strings"
 )
 
-var PropertyPrefixes = []string{"_type::", "_status::", "_prio::"}
-
 type Node struct {
 	ID        string              `json:"id"`
 	Title     string              `json:"title"`
@@ -28,8 +26,9 @@ func (n *Node) AddTag(tag string) {
 	if tag == "" {
 		return
 	}
-	for _, prefix := range PropertyPrefixes {
+	// If it's a property (name::value format), replace any existing tag with the same prefix.
-		if strings.HasPrefix(tag, prefix) {
+	if idx := strings.Index(tag, "::"); idx >= 0 {
+		prefix := tag[:idx+2]
 		var newTags []string
 		for _, t := range n.Tags {
 			if !strings.HasPrefix(t, prefix) {
@@ -37,8 +36,6 @@ func (n *Node) AddTag(tag string) {
 			}
 		}
 		n.Tags = newTags
-			break
-		}
 	}
 	if !slices.Contains(n.Tags, tag) {
 		n.Tags = append(n.Tags, tag)
@@ -86,11 +83,10 @@ func (n *Node) RemoveRelation(relType RelType, target string) {
 }
 
 func (n *Node) GetProperty(k string) string {
+	prefix := "_" + k + "::"
 	for _, t := range n.Tags {
-		if strings.HasPrefix(t, "_") {
+		if strings.HasPrefix(t, prefix) {
-			if p := strings.SplitN(t[1:], "::", 2); len(p) == 2 && p[0] == k {
+			return strings.TrimPrefix(t, prefix)
-				return p[1]
-			}
 		}
 	}
 	return ""

service/node_service.go

@@ -31,44 +31,40 @@ type NodeService interface {
 }
 
 // AddInput describes a new node to create.
-// Tags may include special property tags (_type::, _status::, _prio::); the
+// Rels may contain tag rels (Target == ""), property rels (Target == "",
-// service applies defaults (type=issue, status=open for issues) and validates.
+// Type is "prefix::value"), and edge rels (Target is a node name or ID).
-// Rels may include assignee, in_namespace, blocks, subtask, related, etc.;
+// The service applies defaults (type=issue, status=open for issues) and validates.
-// user and namespace targets are auto-created as needed.
 type AddInput struct {
 	Title   string
 	Content string
 	DueDate string
-	Tags    []string
 	Rels    []RelInput
 }
 
 // UpdateInput describes changes to apply to an existing node.
-// Nil pointer fields mean "no change".
+// AddRels and RemoveRels accept both tag rels (Target == "") and edge rels.
-// Setting _status::done in AddTags is rejected when the node has open blockers.
+// Setting _status::done in AddRels is rejected when the node has open blockers.
 // Adding assignee or in_namespace rels replaces the previous single target.
 type UpdateInput struct {
 	Title      *string
 	Content    *string
 	DueDate    *string // nil = no change; pointer to "" = clear due date
-	AddTags    []string
-	RemoveTags []string
 	AddRels    []RelInput
 	RemoveRels []RelInput
 }
 
 // ListFilter specifies which nodes to return. Empty slices are ignored.
-// Tags are matched as exact tag values or prefixes (e.g. "_status::open").
+// Tag filters (Target == "") match by rel_name prefix.
-// Rels are resolved to node IDs; a missing target returns no results.
+// Edge filters (Target != "") are resolved to node IDs.
 type ListFilter struct {
-	Tags []string
 	Rels []RelInput
 }
 
-// RelInput is a typed, directed edge with a target that may be a name or node ID.
+// RelInput is a typed, directed rel with a target that may be a name or node ID.
+// Target == "" means this is a tag or property rel (no target node).
 type RelInput struct {
 	Type   models.RelType
-	Target string // name or node ID; the service resolves names
+	Target string // name or node ID; the service resolves names. Empty = tag rel.
 }
 
 func InitNodeService(path string) error {

service/node_service_impl.go

@@ -52,7 +52,7 @@ func (ac *accessContext) canWrite(namespaceID string) bool {
 }
 
 // getAccessContext builds an accessContext by reading the current user's outgoing
-// has_write_access and has_read_access edges. If the user node does not yet exist
+// has_write_access and has_read_access rels. If the user node does not yet exist
 // (first-time bootstrap) both maps are empty.
 func (s *nodeServiceImpl) getAccessContext() (*accessContext, error) {
 	ctx := &accessContext{
@@ -91,10 +91,13 @@ func (s *nodeServiceImpl) nodeNamespaceID(n *models.Node) string {
 }
 
 // checkRelTargetWrite verifies the current user has write access to the namespace
-// of each relation target. Targets that do not yet exist are skipped (they will
+// of each edge rel target. Tag rels (empty Target) and targets that do not yet
-// be created during the transaction and access granted there).
+// exist are skipped.
 func (s *nodeServiceImpl) checkRelTargetWrite(ac *accessContext, addRels []RelInput) error {
 	for _, ri := range addRels {
+		if ri.Target == "" {
+			continue // tag rel — no target node to check
+		}
 		targetID, found := s.lookupRelTarget(ri.Type, ri.Target)
 		if !found || targetID == "" {
 			continue
@@ -118,35 +121,33 @@ var (
 	validPrios    = map[string]bool{"high": true, "medium": true, "low": true}
 )
 
-func validateTags(tags []string) error {
+// validateRels checks that any _ -prefixed rel names are known system properties
-	for _, t := range tags {
+// and that their values are valid. Users may not define custom _ -prefixed rels.
-		if v, ok := strings.CutPrefix(t, "_type::"); ok {
+func validateRels(rels []RelInput) error {
+	for _, r := range rels {
+		name := string(r.Type)
+		if !strings.HasPrefix(name, "_") {
+			continue
+		}
+		if v, ok := strings.CutPrefix(name, "_type::"); ok {
 			if !validTypes[v] {
 				return fmt.Errorf("invalid type %q: must be one of issue, note, user, namespace", v)
 			}
-		} else if v, ok := strings.CutPrefix(t, "_status::"); ok {
+		} else if v, ok := strings.CutPrefix(name, "_status::"); ok {
 			if !validStatuses[v] {
 				return fmt.Errorf("invalid status %q: must be one of open, done", v)
 			}
-		} else if v, ok := strings.CutPrefix(t, "_prio::"); ok {
+		} else if v, ok := strings.CutPrefix(name, "_prio::"); ok {
 			if !validPrios[v] {
 				return fmt.Errorf("invalid priority %q: must be one of high, medium, low", v)
 			}
+		} else {
+			return fmt.Errorf("invalid relation %q: custom _ prefix not allowed", name)
 		}
 	}
 	return nil
 }
 
-// tagValue returns the value of the first tag with the given prefix, or "".
-func tagValue(tags []string, prefix string) string {
-	for _, t := range tags {
-		if v, ok := strings.CutPrefix(t, prefix); ok {
-			return v
-		}
-	}
-	return ""
-}
-
 // --- Query ---
 
 func (s *nodeServiceImpl) GetByID(id string) (*models.Node, error) {
@@ -165,15 +166,21 @@ func (s *nodeServiceImpl) GetByID(id string) (*models.Node, error) {
 }
 
 func (s *nodeServiceImpl) List(filter ListFilter) ([]*models.Node, error) {
-	var relFilters []*models.Rel
+	var storeFilters []*models.Rel
 	for _, ri := range filter.Rels {
+		if ri.Target == "" {
+			// Tag filter: pass through with empty target.
+			storeFilters = append(storeFilters, &models.Rel{Type: ri.Type, Target: ""})
+		} else {
+			// Edge filter: resolve target name to node ID.
 			id, ok := s.lookupRelTarget(ri.Type, ri.Target)
 			if !ok {
 				return nil, nil // named target doesn't exist; no nodes can match
 			}
-		relFilters = append(relFilters, &models.Rel{Type: ri.Type, Target: id})
+			storeFilters = append(storeFilters, &models.Rel{Type: ri.Type, Target: id})
 		}
-	nodes, err := s.store.FindNodes(filter.Tags, relFilters)
+	}
+	nodes, err := s.store.FindNodes(storeFilters)
 	if err != nil {
 		return nil, err
 	}
@@ -193,22 +200,28 @@ func (s *nodeServiceImpl) List(filter ListFilter) ([]*models.Node, error) {
 // --- Lifecycle ---
 
 func (s *nodeServiceImpl) Add(input AddInput) (*models.Node, error) {
-	// Copy tags so we can extend without mutating the input.
+	// Build tag set from tag rels (Target == ""), applying property-replacement semantics.
-	tags := make([]string, len(input.Tags))
+	tmp := models.NewNode()
-	copy(tags, input.Tags)
+	for _, r := range input.Rels {
+		if r.Target == "" {
+			tmp.AddTag(string(r.Type))
+		}
+	}
 
 	// Apply defaults.
-	nodeType := tagValue(tags, "_type::")
+	if tmp.GetProperty("type") == "" {
-	if nodeType == "" {
+		tmp.AddTag("_type::issue")
-		nodeType = "issue"
-		tags = append(tags, "_type::issue")
 	}
-	if nodeType == "issue" && tagValue(tags, "_status::") == "" {
+	if tmp.GetProperty("type") == "issue" && tmp.GetProperty("status") == "" {
-		tags = append(tags, "_status::open")
+		tmp.AddTag("_status::open")
 	}
 
-	// Validate special tags.
+	// Validate all rels (including the resolved default tags).
-	if err := validateTags(tags); err != nil {
+	tagRels := make([]RelInput, len(tmp.Tags))
+	for i, t := range tmp.Tags {
+		tagRels[i] = RelInput{Type: models.RelType(t)}
+	}
+	if err := validateRels(append(tagRels, input.Rels...)); err != nil {
 		return nil, err
 	}
 
@@ -217,43 +230,33 @@ func (s *nodeServiceImpl) Add(input AddInput) (*models.Node, error) {
 	if err != nil {
 		return nil, err
 	}
-	// Determine the target namespace name (explicit or default).
 	targetNSName := s.userID
 	for _, ri := range input.Rels {
-		if ri.Type == models.RelInNamespace {
+		if ri.Type == models.RelInNamespace && ri.Target != "" {
 			targetNSName = ri.Target
 			break
 		}
 	}
-	// Check write access only when the namespace already exists; if it doesn't
-	// exist yet it will be created in the transaction and access granted there.
 	if nsID, found := s.lookupRelTarget(models.RelInNamespace, targetNSName); found {
 		if !ac.canWrite(nsID) {
 			return nil, fmt.Errorf("permission denied: no write access to namespace %q", targetNSName)
 		}
 	}
-	// Check write access for all other relation targets.
+	var nonNSEdgeRels []RelInput
-	var nonNSRels []RelInput
 	for _, ri := range input.Rels {
-		if ri.Type != models.RelInNamespace {
+		if ri.Target != "" && ri.Type != models.RelInNamespace {
-			nonNSRels = append(nonNSRels, ri)
+			nonNSEdgeRels = append(nonNSEdgeRels, ri)
 		}
 	}
-	if err := s.checkRelTargetWrite(ac, nonNSRels); err != nil {
+	if err := s.checkRelTargetWrite(ac, nonNSEdgeRels); err != nil {
 		return nil, err
 	}
 
-	// Build initial relation map from rels input.
-	rels := make(map[models.RelType][]string)
 	hasNamespace := false
 	for _, ri := range input.Rels {
-		if ri.Type == models.RelInNamespace {
+		if ri.Type == models.RelInNamespace && ri.Target != "" {
 			hasNamespace = true
 		}
-		rels[ri.Type] = append(rels[ri.Type], ri.Target)
-	}
-	if !hasNamespace {
-		rels[models.RelInNamespace] = []string{s.userID}
 	}
 
 	id, err := s.store.GenerateID()
@@ -267,44 +270,60 @@ func (s *nodeServiceImpl) Add(input AddInput) (*models.Node, error) {
 			return err
 		}
 
+		// Store tag rels.
+		for _, t := range tmp.Tags {
+			if err := st.AddRel(id, t, ""); err != nil {
+				return err
+			}
+		}
+
+		// Mentions.
 		for _, m := range mentions(input.Title + " " + input.Content) {
 			userID, err := s.resolveUserRef(st, m)
 			if err != nil {
 				return err
 			}
-			if err := st.AddEdge(id, userID, models.RelMentions); err != nil {
+			if err := st.AddRel(id, string(models.RelMentions), userID); err != nil {
-				return err
-			}
-		}
-
-		for _, t := range tags {
-			if err := st.AddTag(id, t); err != nil {
 				return err
 			}
 		}
 
+		// Edge rels.
 		hasCreated := false
-		for rt, tgts := range rels {
+		for _, ri := range input.Rels {
-			for _, tgt := range tgts {
+			if ri.Target == "" {
-				if rt == models.RelCreated {
+				continue // already stored as tag
+			}
+			if ri.Type == models.RelCreated {
 				hasCreated = true
 			}
-				resolved, err := s.resolveRelTarget(st, RelInput{Type: rt, Target: tgt})
+			resolved, err := s.resolveRelTarget(st, ri)
 			if err != nil {
 				return err
 			}
-				if err := st.AddEdge(id, resolved, rt); err != nil {
+			if err := st.AddRel(id, string(ri.Type), resolved); err != nil {
 				return err
 			}
 		}
+
+		// Default namespace.
+		if !hasNamespace {
+			nsID, err := s.resolveNamespaceRef(st, s.userID)
+			if err != nil {
+				return err
+			}
+			if err := st.AddRel(id, string(models.RelInNamespace), nsID); err != nil {
+				return err
+			}
 		}
 
+		// Default created.
 		if !hasCreated {
 			userID, err := s.resolveUserRef(st, s.userID)
 			if err != nil {
 				return err
 			}
-			if err := st.AddEdge(id, userID, models.RelCreated); err != nil {
+			if err := st.AddRel(id, string(models.RelCreated), userID); err != nil {
 				return err
 			}
 		}
@@ -318,8 +337,8 @@ func (s *nodeServiceImpl) Add(input AddInput) (*models.Node, error) {
 }
 
 func (s *nodeServiceImpl) Update(id string, input UpdateInput) (*models.Node, error) {
-	// Validate tags before doing any I/O.
+	// Validate rels before doing any I/O.
-	if err := validateTags(input.AddTags); err != nil {
+	if err := validateRels(input.AddRels); err != nil {
 		return nil, err
 	}
 
@@ -340,8 +359,8 @@ func (s *nodeServiceImpl) Update(id string, input UpdateInput) (*models.Node, er
 	}
 
 	// Enforce blocking constraint before allowing status=done.
-	for _, t := range input.AddTags {
+	for _, r := range input.AddRels {
-		if t == "_status::done" {
+		if r.Target == "" && string(r.Type) == "_status::done" {
 			if err := s.checkBlockers(id); err != nil {
 				return nil, err
 			}
@@ -355,7 +374,6 @@ func (s *nodeServiceImpl) Update(id string, input UpdateInput) (*models.Node, er
 			return err
 		}
 
-		// Determine final scalar values.
 		title, content, dueDate := current.Title, current.Content, current.DueDate
 		if input.Title != nil {
 			title = *input.Title
@@ -378,24 +396,28 @@ func (s *nodeServiceImpl) Update(id string, input UpdateInput) (*models.Node, er
 		for _, t := range current.Tags {
 			tmp.AddTag(t)
 		}
-		for _, t := range input.AddTags {
+		for _, r := range input.AddRels {
-			tmp.AddTag(t)
+			if r.Target == "" {
+				tmp.AddTag(string(r.Type))
+			}
+		}
+		for _, r := range input.RemoveRels {
+			if r.Target == "" {
+				tmp.RemoveTag(string(r.Type))
 			}
-		for _, t := range input.RemoveTags {
-			tmp.RemoveTag(t)
 		}
 
 		currentTags, newTags := current.Tags, tmp.Tags
 		for _, t := range currentTags {
 			if !slices.Contains(newTags, t) {
-				if err := st.RemoveTag(id, t); err != nil {
+				if err := st.RemoveRel(id, t, ""); err != nil {
 					return err
 				}
 			}
 		}
 		for _, t := range newTags {
 			if !slices.Contains(currentTags, t) {
-				if err := st.AddTag(id, t); err != nil {
+				if err := st.AddRel(id, t, ""); err != nil {
 					return err
 				}
 			}
@@ -410,6 +432,9 @@ func (s *nodeServiceImpl) Update(id string, input UpdateInput) (*models.Node, er
 
 		currentRels := current.Relations
 		for _, ri := range input.AddRels {
+			if ri.Target == "" {
+				continue // already handled as tag
+			}
 			resolved, err := s.resolveRelTarget(st, ri)
 			if err != nil {
 				return err
@@ -417,22 +442,25 @@ func (s *nodeServiceImpl) Update(id string, input UpdateInput) (*models.Node, er
 			// Single-value relations replace the previous target.
 			if ri.Type == models.RelAssignee || ri.Type == models.RelInNamespace {
 				for _, oldTgt := range currentRels[string(ri.Type)] {
-					if err := st.RemoveEdge(id, oldTgt, ri.Type); err != nil {
+					if err := st.RemoveRel(id, string(ri.Type), oldTgt); err != nil {
 						return err
 					}
 				}
 			}
-			if err := st.AddEdge(id, resolved, ri.Type); err != nil {
+			if err := st.AddRel(id, string(ri.Type), resolved); err != nil {
 				return err
 			}
 		}
 
 		for _, ri := range input.RemoveRels {
+			if ri.Target == "" {
+				continue // already handled as tag
+			}
 			resolved, err := s.resolveRelTarget(st, ri)
 			if err != nil {
 				return err
 			}
-			if err := st.RemoveEdge(id, resolved, ri.Type); err != nil {
+			if err := st.RemoveRel(id, string(ri.Type), resolved); err != nil {
 				return err
 			}
 		}
@@ -476,14 +504,13 @@ func (s *nodeServiceImpl) AddUser(name string) (*models.Node, error) {
 }
 
 func (s *nodeServiceImpl) ListUsers() ([]*models.Node, error) {
-	return s.store.FindNodes([]string{"_type::user"}, nil)
+	return s.store.FindNodes([]*models.Rel{{Type: "_type::user", Target: ""}})
 }
 
 // --- Internal helpers ---
 
 func (s *nodeServiceImpl) checkBlockers(id string) error {
-	// Find all nodes that declare a blocks → id relation (i.e., open blockers).
+	blockers, err := s.store.FindNodes([]*models.Rel{{Type: models.RelBlocks, Target: id}})
-	blockers, err := s.store.FindNodes(nil, []*models.Rel{{Type: models.RelBlocks, Target: id}})
 	if err != nil {
 		return err
 	}
@@ -512,14 +539,14 @@ func (s *nodeServiceImpl) syncMentions(st store.Store, id string, current *model
 		}
 		mentionedUserIDs[userID] = true
 		if !existingMentionIDs[userID] {
-			if err := st.AddEdge(id, userID, models.RelMentions); err != nil {
+			if err := st.AddRel(id, string(models.RelMentions), userID); err != nil {
 				return err
 			}
 		}
 	}
 	for uid := range existingMentionIDs {
 		if !mentionedUserIDs[uid] {
-			if err := st.RemoveEdge(id, uid, models.RelMentions); err != nil {
+			if err := st.RemoveRel(id, string(models.RelMentions), uid); err != nil {
 				return err
 			}
 		}
@@ -536,7 +563,7 @@ func (s *nodeServiceImpl) resolveRelTarget(st store.Store, ri RelInput) (string,
 	case models.RelInNamespace, models.RelHasReadAccess, models.RelHasWriteAccess:
 		return s.resolveNamespaceRef(st, ri.Target)
 	default:
-		return ri.Target, nil // blocks/subtask/related expect raw node IDs
+		return ri.Target, nil // blocks/subtask/related/custom expect raw node IDs
 	}
 }
 
@@ -562,9 +589,9 @@ func (s *nodeServiceImpl) lookupRelTarget(relType models.RelType, target string)
 	return id, true
 }
 
-// resolveIDByNameAndType finds a node by title and _type tag without creating it.
+// resolveIDByNameAndType finds a node by title and _type property without creating it.
 func (s *nodeServiceImpl) resolveIDByNameAndType(st store.Store, title, nodeType string) (string, error) {
-	nodes, err := st.FindNodes([]string{"_type::" + nodeType}, nil)
+	nodes, err := st.FindNodes([]*models.Rel{{Type: models.RelType("_type::" + nodeType), Target: ""}})
 	if err != nil {
 		return "", err
 	}
@@ -599,7 +626,7 @@ func (s *nodeServiceImpl) ensureUser(st store.Store, username string) (string, e
 	if err := st.AddNode(id, username, "", "", now, now); err != nil {
 		return "", err
 	}
-	if err := st.AddTag(id, "_type::user"); err != nil {
+	if err := st.AddRel(id, "_type::user", ""); err != nil {
 		return "", err
 	}
 	return id, nil
@@ -628,21 +655,21 @@ func (s *nodeServiceImpl) ensureNamespace(st store.Store, name string) (string,
 	if err := st.AddNode(id, name, "", "", now, now); err != nil {
 		return "", err
 	}
-	if err := st.AddTag(id, "_type::namespace"); err != nil {
+	if err := st.AddRel(id, "_type::namespace", ""); err != nil {
 		return "", err
 	}
-	if err := st.AddEdge(id, id, models.RelInNamespace); err != nil {
+	if err := st.AddRel(id, string(models.RelInNamespace), id); err != nil {
 		return "", err
 	}
 	userID, err := s.resolveUserRef(st, s.userID)
 	if err != nil {
 		return "", err
 	}
-	if err := st.AddEdge(id, userID, models.RelCreated); err != nil {
+	if err := st.AddRel(id, string(models.RelCreated), userID); err != nil {
 		return "", err
 	}
 	// Grant the creator write access to the new namespace.
-	if err := st.AddEdge(userID, id, models.RelHasWriteAccess); err != nil {
+	if err := st.AddRel(userID, string(models.RelHasWriteAccess), id); err != nil {
 		return "", err
 	}
 	return id, nil

store/sqlite.go

@@ -15,9 +15,7 @@ import (
 
 var migrations = []string{
 	`CREATE TABLE IF NOT EXISTS nodes (id TEXT PRIMARY KEY, title TEXT NOT NULL, content TEXT, due_date TEXT, created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP, updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP)`,
-	`CREATE TABLE IF NOT EXISTS tags (node_id TEXT NOT NULL, tag TEXT NOT NULL, PRIMARY KEY (node_id, tag), FOREIGN KEY (node_id) REFERENCES nodes(id) ON DELETE CASCADE)`,
+	`CREATE TABLE IF NOT EXISTS rels (from_id TEXT NOT NULL, rel_name TEXT NOT NULL, to_id TEXT NOT NULL DEFAULT '', PRIMARY KEY (from_id, rel_name, to_id), FOREIGN KEY (from_id) REFERENCES nodes(id) ON DELETE CASCADE)`,
-	`CREATE TABLE IF NOT EXISTS rels (from_id TEXT NOT NULL, to_id TEXT NOT NULL, rel_type TEXT NOT NULL, PRIMARY KEY (from_id, to_id, rel_type), FOREIGN KEY (from_id) REFERENCES nodes(id) ON DELETE CASCADE, FOREIGN KEY (to_id) REFERENCES nodes(id) ON DELETE CASCADE)`,
-	`CREATE INDEX IF NOT EXISTS idx_tags_tag ON tags(tag)`,
 	`CREATE INDEX IF NOT EXISTS idx_rels_from ON rels(from_id)`,
 	`CREATE INDEX IF NOT EXISTS idx_rels_to ON rels(to_id)`,
 }
@@ -81,22 +79,58 @@ func FindAndOpenSQLiteStore() (Store, error) {
 	}
 }
 
-// NewSQLiteStore opens a SQLite database at the given path and applies
+// NewSQLiteStore opens a SQLite database at the given path, runs a one-time
-// per-connection PRAGMAs. foreign_keys must be set on every connection.
+// schema migration if needed, then applies per-connection PRAGMAs.
 func NewSQLiteStore(path string) (Store, error) {
 	db, err := sql.Open("sqlite", path)
 	if err != nil {
 		return nil, fmt.Errorf("failed to open database: %w", err)
 	}
-	for _, q := range []string{"PRAGMA journal_mode=WAL", "PRAGMA busy_timeout=5000", "PRAGMA foreign_keys=ON"} {
+	// FK must be OFF during migration (table drops/renames).
+	for _, q := range []string{"PRAGMA journal_mode=WAL", "PRAGMA busy_timeout=5000", "PRAGMA foreign_keys=OFF"} {
 		if _, err := db.Exec(q); err != nil {
 			db.Close()
 			return nil, err
 		}
 	}
+	if err := migrateSchema(db); err != nil {
+		db.Close()
+		return nil, fmt.Errorf("schema migration failed: %w", err)
+	}
+	if _, err := db.Exec("PRAGMA foreign_keys=ON"); err != nil {
+		db.Close()
+		return nil, err
+	}
 	return &SQLiteStore{db: db}, nil
 }
 
+// migrateSchema migrates from the legacy two-table (tags + rels) schema to the
+// unified rels-only schema. It is a no-op when migration has already been applied.
+func migrateSchema(db *sql.DB) error {
+	var tagsExists int
+	if err := db.QueryRow("SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name='tags'").Scan(&tagsExists); err != nil {
+		return err
+	}
+	if tagsExists == 0 {
+		return nil // already on new schema
+	}
+	for _, stmt := range []string{
+		`CREATE TABLE rels_new (from_id TEXT NOT NULL, rel_name TEXT NOT NULL, to_id TEXT NOT NULL DEFAULT '', PRIMARY KEY (from_id, rel_name, to_id), FOREIGN KEY (from_id) REFERENCES nodes(id) ON DELETE CASCADE)`,
+		`INSERT OR IGNORE INTO rels_new (from_id, rel_name, to_id) SELECT from_id, rel_type, to_id FROM rels`,
+		`INSERT OR IGNORE INTO rels_new (from_id, rel_name, to_id) SELECT node_id, tag, '' FROM tags`,
+		`DROP TABLE rels`,
+		`DROP TABLE tags`,
+		`ALTER TABLE rels_new RENAME TO rels`,
+		`CREATE INDEX IF NOT EXISTS idx_rels_from ON rels(from_id)`,
+		`CREATE INDEX IF NOT EXISTS idx_rels_to ON rels(to_id)`,
+	} {
+		if _, err := db.Exec(stmt); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
 // --- Transaction ---
 
 func (s *SQLiteStore) Transaction(fn func(Store) error) error {
@@ -137,25 +171,19 @@ func getNode(q querier, id string) (*models.Node, error) {
 	if err != nil {
 		return nil, err
 	}
-	rows, err := q.Query("SELECT tag FROM tags WHERE node_id = ?", id)
+	rows, err := q.Query("SELECT rel_name, to_id FROM rels WHERE from_id = ?", id)
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
 	for rows.Next() {
-		var tag string
+		var relName, toID string
-		rows.Scan(&tag)
+		rows.Scan(&relName, &toID)
-		n.AddTag(tag)
+		if toID == "" {
+			n.AddTag(relName)
+		} else {
+			n.AddRelation(models.RelType(relName), toID)
 		}
-	rows2, err := q.Query("SELECT to_id, rel_type FROM rels WHERE from_id = ?", id)
-	if err != nil {
-		return nil, err
-	}
-	defer rows2.Close()
-	for rows2.Next() {
-		var toID, relType string
-		rows2.Scan(&toID, &relType)
-		n.AddRelation(models.RelType(relType), toID)
 	}
 	return n, nil
 }
@@ -229,81 +257,60 @@ func generateID(q querier) (string, error) {
 func (s *SQLiteStore) GenerateID() (string, error) { return generateID(s.db) }
 func (s *txStore) GenerateID() (string, error)     { return generateID(s.db) }
 
-// --- Tag operations ---
+// --- Rel operations ---
 
-func addTag(q querier, nodeID, tag string) error {
+func addRel(q querier, nodeID, relName, toID string) error {
-	_, err := q.Exec("INSERT OR IGNORE INTO tags (node_id, tag) VALUES (?, ?)", nodeID, tag)
+	_, err := q.Exec("INSERT OR IGNORE INTO rels (from_id, rel_name, to_id) VALUES (?, ?, ?)", nodeID, relName, toID)
 	return err
 }
 
-func removeTag(q querier, nodeID, tag string) error {
+func removeRel(q querier, nodeID, relName, toID string) error {
-	_, err := q.Exec("DELETE FROM tags WHERE node_id = ? AND tag = ?", nodeID, tag)
+	_, err := q.Exec("DELETE FROM rels WHERE from_id = ? AND rel_name = ? AND to_id = ?", nodeID, relName, toID)
 	return err
 }
 
-func (s *SQLiteStore) AddTag(nodeID, tag string) error    { return addTag(s.db, nodeID, tag) }
+func (s *SQLiteStore) AddRel(nodeID, relName, toID string) error {
-func (s *SQLiteStore) RemoveTag(nodeID, tag string) error { return removeTag(s.db, nodeID, tag) }
+	return addRel(s.db, nodeID, relName, toID)
-func (s *txStore) AddTag(nodeID, tag string) error        { return addTag(s.tx, nodeID, tag) }
-func (s *txStore) RemoveTag(nodeID, tag string) error     { return removeTag(s.tx, nodeID, tag) }
-
-// --- Edge operations ---
-
-func addEdge(q querier, fromID, toID string, relType models.RelType) error {
-	_, err := q.Exec("INSERT OR IGNORE INTO rels (from_id, to_id, rel_type) VALUES (?, ?, ?)", fromID, toID, relType)
-	return err
 }
-
+func (s *SQLiteStore) RemoveRel(nodeID, relName, toID string) error {
-func removeEdge(q querier, fromID, toID string, relType models.RelType) error {
+	return removeRel(s.db, nodeID, relName, toID)
-	_, err := q.Exec("DELETE FROM rels WHERE from_id = ? AND to_id = ? AND rel_type = ?", fromID, toID, relType)
-	return err
 }
-
+func (s *txStore) AddRel(nodeID, relName, toID string) error {
-func (s *SQLiteStore) AddEdge(fromID, toID string, relType models.RelType) error {
+	return addRel(s.tx, nodeID, relName, toID)
-	return addEdge(s.db, fromID, toID, relType)
 }
-func (s *SQLiteStore) RemoveEdge(fromID, toID string, relType models.RelType) error {
+func (s *txStore) RemoveRel(nodeID, relName, toID string) error {
-	return removeEdge(s.db, fromID, toID, relType)
+	return removeRel(s.tx, nodeID, relName, toID)
-}
-func (s *txStore) AddEdge(fromID, toID string, relType models.RelType) error {
-	return addEdge(s.tx, fromID, toID, relType)
-}
-func (s *txStore) RemoveEdge(fromID, toID string, relType models.RelType) error {
-	return removeEdge(s.tx, fromID, toID, relType)
 }
 
 // --- FindNodes ---
 
-func findNodes(q querier, tagPrefixes []string, edgeFilters []*models.Rel) ([]*models.Node, error) {
+func findNodes(q querier, filters []*models.Rel) ([]*models.Node, error) {
-	// Edge filter args come first (in JOIN ON clauses), tag args come last (in HAVING).
 	query := "SELECT DISTINCT n.id FROM nodes n"
 	var joins []string
 	var args []any
 
-	// Edge filtering: each filter becomes an inner join with conditions in the ON clause.
+	for i, f := range filters {
-	for i, ef := range edgeFilters {
 		alias := fmt.Sprintf("r%d", i)
+		if f.Target == "" {
+			// Tag/property filter: match rels with empty to_id by rel_name prefix.
 			joins = append(joins, fmt.Sprintf(
-			"JOIN rels %s ON n.id = %s.from_id AND %s.rel_type = ? AND %s.to_id = ?",
+				"JOIN rels %s ON n.id = %s.from_id AND %s.to_id = '' AND %s.rel_name LIKE ? || '%%'",
 				alias, alias, alias, alias,
 			))
-		args = append(args, string(ef.Type), ef.Target)
+			args = append(args, string(f.Type))
+		} else {
+			// Edge filter: match rel by exact rel_name and to_id.
+			joins = append(joins, fmt.Sprintf(
+				"JOIN rels %s ON n.id = %s.from_id AND %s.rel_name = ? AND %s.to_id = ?",
+				alias, alias, alias, alias,
+			))
+			args = append(args, string(f.Type), f.Target)
+		}
 	}
 
-	// Tag filtering: join tags and use HAVING with aggregate to require all prefixes.
+	if len(joins) > 0 {
-	joins = append(joins, "JOIN tags t_tag ON n.id = t_tag.node_id")
-	if len(tagPrefixes) == 0 {
-		tagPrefixes = []string{""}
-	}
-	cond := ""
-	for _, t := range tagPrefixes {
-		cond += "t_tag.tag LIKE ? || '%' OR "
-		args = append(args, t)
-	}
-	having := "SUM(CASE WHEN " + cond[:len(cond)-4] + " THEN 1 ELSE 0 END) >= ?"
-	args = append(args, len(tagPrefixes))
-
 		query += " " + strings.Join(joins, " ")
-	query += " GROUP BY n.id HAVING " + having
+	}
 	query += " ORDER BY n.created_at DESC"
 
 	rows, err := q.Query(query, args...)
@@ -332,10 +339,10 @@ func findNodes(q querier, tagPrefixes []string, edgeFilters []*models.Rel) ([]*m
 	return nodes, nil
 }
 
-func (s *SQLiteStore) FindNodes(tagPrefixes []string, edgeFilters []*models.Rel) ([]*models.Node, error) {
+func (s *SQLiteStore) FindNodes(filters []*models.Rel) ([]*models.Node, error) {
-	return findNodes(s.db, tagPrefixes, edgeFilters)
+	return findNodes(s.db, filters)
 }
 
-func (s *txStore) FindNodes(tagPrefixes []string, edgeFilters []*models.Rel) ([]*models.Node, error) {
+func (s *txStore) FindNodes(filters []*models.Rel) ([]*models.Node, error) {
-	return findNodes(s.tx, tagPrefixes, edgeFilters)
+	return findNodes(s.tx, filters)
 }

store/store.go

@@ -3,26 +3,25 @@ package store
 import "axolotl/models"
 
 // Store is a primitive graph persistence interface. It provides basic
-// operations for nodes, tags, and directed edges. No business logic lives here.
+// operations for nodes and directed rels. No business logic lives here.
+// "Tag" rels are rels with an empty toID (e.g. "_type::issue" or "backend").
 type Store interface {
 	// Nodes
 	AddNode(id, title, content, dueDate, createdAt, updatedAt string) error
-	GetNode(id string) (*models.Node, error) // returns node with tags and edges populated
+	GetNode(id string) (*models.Node, error) // returns node with tags and rels populated
 	UpdateNode(id, title, content, dueDate, updatedAt string) error // empty dueDate stores NULL
 	DeleteNode(id string) error
 	NodeExists(id string) (bool, error)
 	GenerateID() (string, error) // returns a random 5-char ID guaranteed unique in the store
 
-	// Tags
+	// Rels: relName is the relation name; toID is empty for "tag" rels (properties/labels).
-	AddTag(nodeID, tag string) error
+	AddRel(nodeID, relName, toID string) error
-	RemoveTag(nodeID, tag string) error
+	RemoveRel(nodeID, relName, toID string) error
 
-	// Edges (directed, typed)
+	// FindNodes returns fully-populated nodes matching all given filters.
-	AddEdge(fromID, toID string, relType models.RelType) error
+	// Filters with empty Target match nodes by rel_name prefix with empty toID (tag/property).
-	RemoveEdge(fromID, toID string, relType models.RelType) error
+	// Filters with non-empty Target match nodes by exact rel_name and toID (edge).
-
+	FindNodes(filters []*models.Rel) ([]*models.Node, error)
-	// Query returns fully-populated nodes matching all given tag prefixes and edge filters.
-	FindNodes(tagPrefixes []string, edgeFilters []*models.Rel) ([]*models.Node, error)
 
 	// Transaction runs fn inside an atomic transaction. If fn returns an error
 	// the transaction is rolled back; otherwise it is committed.