Merge pull request #726 from gastownhall/fix/infix-on-julian-probe-complete

Remove formula and order filename infixes on track1 (supersedes #723)

Author: julianknutsen

cmd/gc/builtin_prompts_test.go

@@ -65,7 +65,7 @@ func TestMaterializeBuiltinFormulas(t *testing.T) {
 	if err := materializeBuiltinFormulas(dir); err != nil {
 		t.Fatalf("materializeBuiltinFormulas: %v", err)
 	}
-	if _, err := os.Stat(filepath.Join(dir, citylayout.FormulasRoot, "pancakes.formula.toml")); !os.IsNotExist(err) {
+	if _, err := os.Stat(filepath.Join(dir, citylayout.FormulasRoot, "pancakes.toml")); !os.IsNotExist(err) {
 		t.Fatalf("materializeBuiltinFormulas should not write city-local formula seeds on start")
 	}
 }
@@ -78,7 +78,7 @@ func TestMaterializeBuiltinFormulasOverwrites(t *testing.T) {
 	}
 
 	// Write stale content.
-	stale := filepath.Join(formulasDir, "pancakes.formula.toml")
+	stale := filepath.Join(formulasDir, "pancakes.toml")
 	if err := os.WriteFile(stale, []byte("stale"), 0o644); err != nil {
 		t.Fatal(err)
 	}

cmd/gc/cmd_formula.go

@@ -39,19 +39,23 @@ configured via packs and formulas_dir settings.`,
 				return nil
 			}
 
-			// Scan search paths for .formula.toml files, deduplicating by name
-			// (last path wins, matching formula layer resolution order).
+			// Scan search paths for canonical and legacy formula TOML files,
+			// deduplicating by name (last path wins, matching formula layer
+			// resolution order).
 			winners := make(map[string]bool)
 			for _, dir := range paths {
 				entries, err := os.ReadDir(dir)
 				if err != nil {
 					continue
 				}
 				for _, e := range entries {
-					if e.IsDir() || !strings.HasSuffix(e.Name(), ".formula.toml") {
+					if e.IsDir() {
+						continue
+					}
+					name, ok := formula.TrimTOMLFilename(e.Name())
+					if !ok {
 						continue
 					}
-					name := strings.TrimSuffix(e.Name(), ".formula.toml")
 					winners[name] = true
 				}
 			}

cmd/gc/cmd_order.go

@@ -24,7 +24,7 @@ func newOrderCmd(stdout, stderr io.Writer) *cobra.Command {
 		Short: "Manage orders (scheduled and event-driven dispatch)",
 		Long: `Manage orders — scheduled or event-driven dispatch of formulas and scripts.
 
-Orders live in orders/NAME/order.toml files. Each order pairs a gate
+Orders live in flat orders/<name>.toml files. Each order pairs a gate
 condition (cooldown, cron, condition, event, or manual) with an action
 (a formula or an exec script). The controller evaluates gates on each
 tick and dispatches work when a gate opens.`,
@@ -54,7 +54,7 @@ func newOrderListCmd(stdout, stderr io.Writer) *cobra.Command {
 		Short: "List available orders",
 		Long: `List all available orders with their gate type, schedule, and target.
 
-Scans orders/ directories for order.toml files defining gate conditions,
+Scans orders/ directories for flat .toml files defining gate conditions,
 scheduling parameters, and target pools.`,
 		Args: cobra.NoArgs,
 		RunE: func(_ *cobra.Command, _ []string) error {

cmd/gc/cmd_order_test.go

@@ -322,7 +322,7 @@ schedule = "*/5 * * * *"
 		}
 	})
 
-	if !strings.Contains(logs, "move to orders/health-check.order.toml") {
+	if !strings.Contains(logs, "move to orders/health-check.toml") {
 		t.Fatalf("logs = %q, want move warning", logs)
 	}
 }

cmd/gc/cmd_supervisor_test.go

@@ -398,7 +398,7 @@ func TestPrepareCityForSupervisorEnsuresInitArtifacts(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	initFormula := filepath.Join(cityPath, citylayout.FormulasRoot, "mol-do-work.formula.toml")
+	initFormula := filepath.Join(cityPath, citylayout.FormulasRoot, "mol-do-work.toml")
 	if _, err := os.Stat(initFormula); !os.IsNotExist(err) {
 		t.Fatalf("init formula should not exist before supervisor prep, err=%v", err)
 	}

cmd/gc/embed_builtin_packs.go

@@ -13,6 +13,7 @@ import (
 	"github.com/gastownhall/gascity/examples/gastown/packs/gastown"
 	"github.com/gastownhall/gascity/examples/gastown/packs/maintenance"
 	"github.com/gastownhall/gascity/internal/citylayout"
+	"github.com/gastownhall/gascity/internal/orders"
 )
 
 // builtinPack pairs an embedded FS with the subdirectory name used under .gc/system/packs/.
@@ -22,7 +23,6 @@ type builtinPack struct {
 }
 
 const (
-	embeddedOrderSuffix   = ".order.toml"
 	legacyOrderConfigFile = "order.toml"
 )
 
@@ -151,7 +151,7 @@ func materializeFS(embedded fs.FS, root, dstDir string) error {
 }
 
 // pruneLegacyEmbeddedOrders removes deprecated order directory layouts when the
-// embedded pack already provides the flat orders/<name>.order.toml form.
+// embedded pack already provides the flat orders/<name>.toml form.
 func pruneLegacyEmbeddedOrders(embedded fs.FS, dstDir string) error {
 	entries, err := fs.ReadDir(embedded, "orders")
 	if err != nil {
@@ -162,10 +162,10 @@ func pruneLegacyEmbeddedOrders(embedded fs.FS, dstDir string) error {
 			continue
 		}
 		name := entry.Name()
-		if !strings.HasSuffix(name, embeddedOrderSuffix) {
+		orderName, ok := orders.TrimFlatOrderFilename(name)
+		if !ok {
 			continue
 		}
-		orderName := strings.TrimSuffix(name, embeddedOrderSuffix)
 		for _, legacyPath := range []string{
 			filepath.Join(dstDir, "orders", orderName, legacyOrderConfigFile),
 			filepath.Join(dstDir, "formulas", "orders", orderName, legacyOrderConfigFile),

cmd/gc/embed_builtin_packs_test.go

@@ -81,11 +81,11 @@ func TestMaterializeBuiltinPacks(t *testing.T) {
 
 	// Verify embedded order files are materialized alongside formulas.
 	for _, order := range []string{
-		filepath.Join(dir, citylayout.SystemPacksRoot, "maintenance", "orders", "gate-sweep.order.toml"),
-		filepath.Join(dir, citylayout.SystemPacksRoot, "maintenance", "orders", "mol-dog-jsonl.order.toml"),
-		filepath.Join(dir, citylayout.SystemPacksRoot, "maintenance", "orders", "mol-dog-reaper.order.toml"),
-		filepath.Join(dir, citylayout.SystemPacksRoot, "dolt", "orders", "dolt-health.order.toml"),
-		filepath.Join(dir, citylayout.SystemPacksRoot, "gastown", "orders", "digest-generate.order.toml"),
+		filepath.Join(dir, citylayout.SystemPacksRoot, "maintenance", "orders", "gate-sweep.toml"),
+		filepath.Join(dir, citylayout.SystemPacksRoot, "maintenance", "orders", "mol-dog-jsonl.toml"),
+		filepath.Join(dir, citylayout.SystemPacksRoot, "maintenance", "orders", "mol-dog-reaper.toml"),
+		filepath.Join(dir, citylayout.SystemPacksRoot, "dolt", "orders", "dolt-health.toml"),
+		filepath.Join(dir, citylayout.SystemPacksRoot, "gastown", "orders", "digest-generate.toml"),
 	} {
 		if _, err := os.Stat(order); err != nil {
 			t.Errorf("embedded order missing: %v", err)
@@ -181,9 +181,9 @@ func TestMaterializeBuiltinPacks_PrunesLegacyOrderDirs(t *testing.T) {
 	}
 
 	for _, path := range []string{
-		filepath.Join(dir, citylayout.SystemPacksRoot, "maintenance", "orders", "gate-sweep.order.toml"),
-		filepath.Join(dir, citylayout.SystemPacksRoot, "dolt", "orders", "dolt-health.order.toml"),
-		filepath.Join(dir, citylayout.SystemPacksRoot, "gastown", "orders", "digest-generate.order.toml"),
+		filepath.Join(dir, citylayout.SystemPacksRoot, "maintenance", "orders", "gate-sweep.toml"),
+		filepath.Join(dir, citylayout.SystemPacksRoot, "dolt", "orders", "dolt-health.toml"),
+		filepath.Join(dir, citylayout.SystemPacksRoot, "gastown", "orders", "digest-generate.toml"),
 	} {
 		if _, err := os.Stat(path); err != nil {
 			t.Fatalf("flat order missing after materialization: %v", err)

cmd/gc/formula_resolve.go

@@ -4,58 +4,90 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
-	"strings"
+
+	"github.com/gastownhall/gascity/internal/formula"
 )
 
-// ResolveFormulas computes per-filename winners from layered formula
-// directories and creates symlinks in targetDir/.beads/formulas/.
+// ResolveFormulas computes per-formula-name winners from layered formula
+// directories and creates canonical .toml symlinks in targetDir/.beads/formulas/.
 //
-// Layers are ordered lowest→highest priority. For each *.formula.toml file
-// found across all layers, the highest-priority layer wins. Winners are
-// symlinked into targetDir/.beads/formulas/ so bd finds them natively.
+// Layers are ordered lowest→highest priority. For each formula name (derived
+// from either canonical or legacy filename form), the highest-priority layer
+// wins. Winners are symlinked into targetDir/.beads/formulas/<name>.toml so
+// bd finds them natively using the canonical filename, regardless of the
+// source file's on-disk name.
 //
 // Idempotent: correct symlinks are left alone, stale ones are updated,
-// and symlinks for formulas no longer in any layer are removed. Real files
+// and symlinks for formulas no longer in any layer are removed (including
+// any stray legacy-suffixed symlinks from earlier runs). Real files
 // (non-symlinks) in the target directory are never overwritten.
 func ResolveFormulas(targetDir string, layers []string) error {
 	if len(layers) == 0 {
 		return nil
 	}
 
-	// Build winner map: filename → absolute source path.
-	// Later layers overwrite earlier ones (higher priority).
+	// Build winner map keyed by formula NAME (not filename). Later layers
+	// overwrite earlier ones (higher priority). Within a single layer, the
+	// canonical .toml form wins over the legacy .formula.toml form so a
+	// partially-migrated layer does not shadow its own canonical file.
 	winners := make(map[string]string)
 	for _, layerDir := range layers {
 		entries, err := os.ReadDir(layerDir)
 		if err != nil {
 			continue // Layer dir doesn't exist — skip (not an error).
 		}
+		// Resolve within-layer winners first so canonical beats legacy
+		// sibling regardless of ReadDir order, then merge into the
+		// cross-layer winners map (overwriting lower layers).
+		layerPick := make(map[string]string)
+		layerLegacy := make(map[string]bool)
 		for _, e := range entries {
-			if e.IsDir() || !strings.HasSuffix(e.Name(), ".formula.toml") {
+			if e.IsDir() {
+				continue
+			}
+			name, ok := formula.TrimTOMLFilename(e.Name())
+			if !ok {
 				continue
 			}
+			legacy := e.Name() == name+formula.LegacyTOMLExt
+			if _, exists := layerPick[name]; exists && legacy && !layerLegacy[name] {
+				continue // Canonical already picked in this layer — skip legacy sibling.
+			}
 			abs, err := filepath.Abs(filepath.Join(layerDir, e.Name()))
 			if err != nil {
 				continue
 			}
-			winners[e.Name()] = abs
+			layerPick[name] = abs
+			layerLegacy[name] = legacy
 		}
+		for name, abs := range layerPick {
+			winners[name] = abs
+		}
+	}
+
+	// Build the set of canonical filenames we will emit. cleanStaleFormulaSymlinks
+	// uses this to garbage-collect any legacy-suffixed symlinks from prior runs.
+	canonicalNames := make(map[string]string, len(winners))
+	for name, src := range winners {
+		canonicalNames[name+formula.CanonicalTOMLExt] = src
 	}
 
 	symlinkDir := filepath.Join(targetDir, ".beads", "formulas")
 
 	if len(winners) == 0 {
-		return cleanStaleFormulaSymlinks(symlinkDir, winners)
+		return cleanStaleFormulaSymlinks(symlinkDir, canonicalNames)
 	}
 
 	// Ensure target symlink directory exists.
 	if err := os.MkdirAll(symlinkDir, 0o755); err != nil {
 		return fmt.Errorf("creating formula symlink dir: %w", err)
 	}
 
-	// Create/update symlinks for winners.
-	for name, srcPath := range winners {
-		linkPath := filepath.Join(symlinkDir, name)
+	// Create/update canonical symlinks for winners. The link is always named
+	// <formula-name>.toml regardless of whether the winning source file on
+	// disk uses the canonical or legacy extension.
+	for linkName, srcPath := range canonicalNames {
+		linkPath := filepath.Join(symlinkDir, linkName)
 
 		// Check if a real file (non-symlink) exists — don't overwrite.
 		fi, err := os.Lstat(linkPath)
@@ -74,11 +106,11 @@ func ResolveFormulas(targetDir string, layers []string) error {
 		}
 
 		if err := os.Symlink(srcPath, linkPath); err != nil {
-			return fmt.Errorf("creating formula symlink %q → %q: %w", name, srcPath, err)
+			return fmt.Errorf("creating formula symlink %q → %q: %w", linkName, srcPath, err)
 		}
 	}
 
-	return cleanStaleFormulaSymlinks(symlinkDir, winners)
+	return cleanStaleFormulaSymlinks(symlinkDir, canonicalNames)
 }
 
 // cleanStaleFormulaSymlinks removes symlinks in symlinkDir that are not in
@@ -91,7 +123,7 @@ func cleanStaleFormulaSymlinks(symlinkDir string, winners map[string]string) err
 		return nil // Can't read — nothing to clean up.
 	}
 	for _, e := range entries {
-		if e.IsDir() || !strings.HasSuffix(e.Name(), ".formula.toml") {
+		if e.IsDir() || !formula.IsTOMLFilename(e.Name()) {
 			continue
 		}
 		linkPath := filepath.Join(symlinkDir, e.Name())