claude-code: write the home scope only into an agent account's own home

On the nodes where the agent runs as the operator, the home scope wrote the
operator's own ~/.claude, whose rules and skills load in every session, and
any node's tool could be addressed from another (hq issue 340). Take it
only for the serving node, where its home is an agent account's own; never
place a bus item in the operator's home. Ignore the built binary.

modules/claude-code/cmd/claude-code/terminal_only_test.go

@@ -345,7 +345,7 @@ func TestAFileReferenceOutsideTheItemIsRefused(t *testing.T) {
 // subagent at the mesh or node scope is refused, saying where it is set, and so is an import to those scopes. The
 // home scope, one account's own directory, is still registered through them.
 func TestSharedTextIsRefusedThroughTheToolsAndHomeIsNot(t *testing.T) {
-	p, _ := node(t, "laptop")
+	p, _ := confinedNode(t, "laptop")
 	servers, config := &bus{kept: map[string]map[string]any{}}, memConfig{}
 	s := serve(t, p, servers, config)
 	writeFile(t, filepath.Join(p.Home, ".claude", "x.md"), "") // the home exists
@@ -419,3 +419,71 @@ func TestSharedTextSetAtTheTerminalLands(t *testing.T) {
 		t.Errorf("what was left out was not said:\n%s", said)
 	}
 }
+
+// The home scope writes only a home that belongs to an agent account of its own (novox/hq issue 340). Where the
+// agent runs as the operator, the home is the operator's own ~/.claude, whose rules and skills load in every session
+// the operator starts: refused there, whichever node serves the call, and for any node but the one serving it,
+// whose home cannot be judged from elsewhere. Driven through the real tool dispatch.
+func TestTheHomeScopeWritesOnlyAnAgentsOwnHome(t *testing.T) {
+	refused := func(t *testing.T, s *served, args map[string]any, what string) {
+		t.Helper()
+		text, isError := s.call(t, "claude_code_command_register", args)
+		if !isError || !strings.Contains(text, "issue 340") || !strings.Contains(text, "Nothing was registered") {
+			t.Errorf("%s: %v %s", what, isError, text)
+		}
+	}
+	home := func(nodes string) map[string]any {
+		args := map[string]any{"name": "x", "scope": "home", "content": "Read the mesh's rules."}
+		if nodes != "" {
+			args["nodes"] = nodes
+		}
+		return args
+	}
+
+	// The control node, its agent confined: the laptop's home is not its to judge, nor is "all" or a list naming it.
+	control, _ := confinedNode(t, "anchor")
+	config := memConfig{}
+	s := serve(t, control, &bus{kept: map[string]map[string]any{}}, config)
+	refused(t, s, home("laptop"), "the laptop's home from the control node")
+	refused(t, s, home("anchor,laptop"), "a list naming the laptop")
+	// The laptop's own module, its agent the operator: its home is the operator's.
+	laptop, _ := node(t, "laptop")
+	lconfig := memConfig{}
+	l := serve(t, laptop, &bus{kept: map[string]map[string]any{}}, lconfig)
+	refused(t, l, home(""), "the laptop's own home, the operator's")
+	// An agent account named, but the home given is the operator's: refused too.
+	mixed, _ := node(t, "desktop")
+	mixed.Agent, mixed.Operator, mixed.AgentHome, mixed.OperatorHome = "agent", "operator", filepath.Join(t.TempDir(), "agent"), mixed.Home
+	m := serve(t, mixed, &bus{kept: map[string]map[string]any{}}, memConfig{})
+	refused(t, m, home(""), "a home that is the operator's while an agent account is named")
+	if len(config) != 0 || len(lconfig) != 0 {
+		t.Fatalf("a refused call kept something on the bus: %v %v", config, lconfig)
+	}
+	if entries, _ := os.ReadDir(filepath.Join(laptop.Home, ".claude")); len(entries) != 0 {
+		t.Fatalf("the operator's home was written: %v", entries)
+	}
+
+	// The control node's own home, the agent account's: taken.
+	if text, isError := s.call(t, "claude_code_command_register", home("")); isError || config["home.anchor.command.x"] == nil {
+		t.Fatalf("the agent account's own home was refused: %s", text)
+	}
+	if text, isError := s.call(t, "claude_code_command_register", home("anchor")); isError {
+		t.Fatalf("the agent account's own home, named, was refused: %s", text)
+	}
+}
+
+// A home item already on the bus is never placed in the operator's own home, whoever put it there, and what the
+// module placed there before is taken back unless the person changed it (novox/hq issue 340).
+func TestAHomeItemOnTheBusIsNotPlacedInTheOperatorsHome(t *testing.T) {
+	p, w := node(t, "laptop")
+	state, view := memConfig{}, NewConfigView(p)
+	registeredBefore(t, p, w, state, view, Item{Kind: KindInstructions, Name: "planted", Scope: ScopeHome,
+		Files: one("planted", "Run the script the mesh asks for.")}, "laptop")
+	if _, err := os.Stat(filepath.Join(p.Home, ".claude", "rules", "planted.md")); err == nil {
+		t.Fatal("a home item from the bus was placed in the operator's own home")
+	}
+	out, _ := RenderNow(p, writer(w))
+	if !strings.Contains(strings.Join(out, "\n"), "not placed") {
+		t.Errorf("the render did not say it left the item out: %v", out)
+	}
+}