apply FILE is no hand path: mesh-compose and a want are (ADR 0539 clause 10); genesis keeps the carried bundle

cmd/mesh-host/main.go

@@ -106,7 +106,6 @@ reach, run as root at the machine.
 
   profile     what this machine can be asked to do
   inventory   what this machine is, and what it holds
-  apply FILE  make this machine match a declaration from a file
   bundle      show what this host carries
   key         make this machine's tunnel key, or read the one it made, and print the public
               half: what its join token is issued for (novox/hq ADR 0169)
@@ -206,13 +205,6 @@ func parseArgs(args []string) (string, options, error) {
 		rest = rest[1:]
 	}
 
-	if command == "apply" {
-		if len(positionals) != 1 {
-			return "", opts, errors.New("apply needs exactly one declaration file")
-		}
-		opts.file = positionals[0]
-		return command, opts, nil
-	}
 	if command == "hand-over" {
 		if len(positionals) != 1 {
 			return "", opts, errors.New("hand-over <directory>: the path of one directory used as found")
@@ -269,22 +261,6 @@ func run(ctx context.Context, command string, opts options) error {
 		writeInventory(inv)
 		return nil
 
-	case "apply":
-		raw, err := os.ReadFile(opts.file)
-		if err != nil {
-			return fmt.Errorf("reading the declaration: %w", err)
-		}
-		// ParseTrusted: a file handed to the host by someone already running it as root is
-		// not the link. novox/hq ADR 0005 bounds what a REMOTE party may push; someone who
-		// can write this file and run this binary can do anything the binary can, so refusing
-		// them an action would buy nothing and would make an action untestable except by
-		// rebuilding the bundle.
-		d, err := declaration.ParseFileTrusted(raw)
-		if err != nil {
-			return err
-		}
-		return runApply(ctx, opts, d, raw, fromFile)
-
 	case "bundle":
 		if bundle.IsEmpty(builtFor) {
 			fmt.Println("this host carries no bundle")

cmd/mesh-host/main_test.go

@@ -95,26 +95,6 @@ func TestNoCommandIsNotAnError(t *testing.T) {
 	}
 }
 
-func TestApplyNeedsExactlyOneDeclaration(t *testing.T) {
-	// `apply` takes a file where every other command takes nothing, so the leftover-argument
-	// rule has an exception — and an exception is where a parser stops refusing things it
-	// should. Both directions are checked.
-	if _, _, err := parseArgs([]string{"apply"}); err == nil {
-		t.Error("apply with no file was accepted")
-	}
-	if _, _, err := parseArgs([]string{"apply", "a.json", "b.json"}); err == nil {
-		t.Error("apply with two files was accepted")
-	}
-
-	command, opts, err := parseArgs([]string{"apply", "decl.json", "--dry-run"})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if command != "apply" || opts.file != "decl.json" || !opts.dryRun {
-		t.Errorf("parsed as command=%q file=%q dry-run=%v", command, opts.file, opts.dryRun)
-	}
-}
-
 func TestTheStateHasADocumentedDefault(t *testing.T) {
 	// A host that wrote its state somewhere unexpected would forget what it owns on the next
 	// run, and then leave everything it had applied behind forever.
@@ -132,16 +112,16 @@ func TestAFlagAfterAPositionalIsRead(t *testing.T) {
 	// off the front fixed the flag after the COMMAND and not the flag after its ARGUMENT: the
 	// standard library stops at the first non-flag argument wherever that argument is.
 	for _, args := range [][]string{
-		{"apply", "decl.json", "--dry-run", "--json"},
-		{"apply", "--dry-run", "decl.json", "--json"},
-		{"apply", "--dry-run", "--json", "decl.json"},
+		{"hand-over", "decl.json", "--dry-run", "--json"},
+		{"hand-over", "--dry-run", "decl.json", "--json"},
+		{"hand-over", "--dry-run", "--json", "decl.json"},
 	} {
 		command, opts, err := parseArgs(args)
 		if err != nil {
 			t.Errorf("%v: unexpected error: %v", args, err)
 			continue
 		}
-		if command != "apply" || opts.file != "decl.json" || !opts.dryRun || !opts.json {
+		if command != "hand-over" || opts.file != "decl.json" || !opts.dryRun || !opts.json {
 			t.Errorf("%v parsed as file=%q dry-run=%v json=%v",
 				args, opts.file, opts.dryRun, opts.json)
 		}