fix: keep name-based stop inside the current project

`stop --name` filtered background sessions of every project, so the name
collision the positional form now guards against was still reachable
through the flag. Both forms are project-scoped; an unresolvable project
matches nothing instead of the whole host.

Only a complete container ID may extend a recorded (truncated) one, since
a value of some length in between cannot be verified against it.

Author: planger

docs/cli-reference.md

@@ -41,7 +41,9 @@ unchanged. See [windows.md](windows.md).
 names are matched in sanitized form on both sides (lowercased,
 non-alphanumerics collapsed to `-`, truncated to 32 characters), so a session
 started as `--name "My Task"` is reachable as either `my-task` or `"My Task"`.
-The same holds for the `--name` filter of `ps`, `status`, and `stop`.
+The same holds for the `--name` filter of `ps`, `status`, and `stop`; a `--name`
+that is blank or sanitizes to nothing matches no session rather than all of
+them.
 
 Session names are resolved against the current project first (same worktree,
 then same project); they are not required to be unique, so when one matches
@@ -51,16 +53,17 @@ resolves verbatim, independently of the working directory and `--tool`; an
 ambiguous container-ID prefix is reported like an ambiguous name.
 
 `attach` and `theia` widen the search to all projects when the current one has
-no match. `stop <name>` does not: removal is destructive and the auto-assigned
-names `1`, `2`, … collide across projects by construction, so another project's
-session has to be named by its container name or ID.
-
-`stop <name>` and `stop --name <name>` are different commands. The positional
-form removes the single session it resolves, whatever its tool and whether it is
-running or already stopped. `--name` filters the batch form instead: it removes
-every *background* session of the selected tool (`--tool`, default `claude`)
-whose session name matches. A `--name` that is blank or sanitizes to nothing
-matches no session rather than all of them.
+no match. `stop` never does, neither for `stop <name>` nor for `stop --name`:
+removal is destructive and the auto-assigned names `1`, `2`, … collide across
+projects by construction, so another project's session has to be named by its
+container name or ID.
+
+`stop <name>` and `stop --name <name>` still select differently. The positional
+form removes exactly the one session it resolves, of any tool unless `--tool` is
+passed. `--name` filters the batch form instead: it removes every *background*
+session of the current project whose name matches, for the single tool that the
+options resolve to (so a profile or config `tool` applies as well). Both include
+containers that have already exited.
 
 With no argument, `attach` picks the single detached session of the current
 project (a foreground session is entered with `exec` instead), and `theia` picks

docs/persistence.md

@@ -14,7 +14,7 @@ enclave resume                   # Session picker (falls back to continue)
 
 If a container name is already in use, a new session starts with a unique name. Use `exec` to attach to the default container name.
 
-Containers are named `enclave-<tool>-<project-hash>-<session>`, so the same session name can be used in several projects. `attach`, `stop <name>`, and `theia` resolve a session name within the current project first; when a name matches containers in more than one project, the candidates are listed and a full container name must be passed. `attach` and `theia` also accept a name that only exists in another project; `stop` does not, since removing a container is destructive — pass its container name instead.
+Containers are named `enclave-<tool>-<project-hash>-<session>`, so the same session name can be used in several projects. `attach`, `stop <name>`, and `theia` resolve a session name within the current project first; when a name matches containers in more than one project, the candidates are listed and a full container name must be passed. `attach` and `theia` also accept a name that only exists in another project; `stop` does not — neither by argument nor by `--name` — since removing a container is destructive: pass its container name instead.
 
 ## Managing Running Containers
 

internal/app/command_stop.go

@@ -44,7 +44,8 @@ func runStop(opts model.Options, projectDir string) int {
 
 // stopSessions removes the containers a `stop` invocation selects: the single
 // session named by the positional argument, or every background session of the
-// tool, narrowed by `--name` when that flag was given.
+// tool, narrowed to the current project's matching sessions when `--name` was
+// given.
 func stopSessions(ctx context.Context, be backend.Backend, opts model.Options, projectDir string) int {
 	run := opts.RunOptions
 
@@ -71,9 +72,12 @@ func stopSessions(ctx context.Context, be backend.Backend, opts model.Options, p
 		return 1
 	}
 	// Sanitized matching happens here rather than as a label filter, so that a
-	// name which sanitizes to nothing stops nothing instead of everything.
+	// name which sanitizes to nothing stops nothing instead of everything. Like
+	// the positional form, `--name` stays inside the current project: session
+	// names are project-relative and collide across projects.
 	if name, given := sessionNameFilter(opts); given {
-		sessions = sessionsMatchingName(sessions, name)
+		project := sessionTargetProject(projectDir)
+		sessions = sessionsMatchingName(projectHashSessions(sessions, project.Hash), name)
 	}
 
 	if len(sessions) == 0 {

internal/app/command_stop_test.go

@@ -14,6 +14,7 @@ import (
 	"testing"
 
 	"enclave/internal/backend"
+	"enclave/internal/config"
 	"enclave/internal/model"
 )
 
@@ -36,48 +37,64 @@ func TestStopContainerFinalizesThenForceRemovesOnFinalizeError(t *testing.T) {
 	}
 }
 
-func TestStopSessionsRequiresANameToStopSomething(t *testing.T) {
-	sessions := []backend.Session{
-		session("enclave-claude-aaaaaaaaaaaa-my-task", "my-task", "aaaaaaaaaaaa", "/repo/a"),
-		session("enclave-claude-aaaaaaaaaaaa-other", "other", "aaaaaaaaaaaa", "/repo/a"),
+func TestStopSessionsSelection(t *testing.T) {
+	projectDir := t.TempDir()
+	project, err := config.ResolveProjectFromDir(projectDir)
+	if err != nil {
+		t.Fatalf("ResolveProjectFromDir() error = %v", err)
 	}
+	mine := session("enclave-claude-"+project.Hash+"-my-task", "my-task", project.Hash, projectDir)
+	other := session("enclave-claude-"+project.Hash+"-other", "other", project.Hash, projectDir)
+	foreign := session("enclave-claude-bbbbbbbbbbbb-my-task", "my-task", "bbbbbbbbbbbb", "/repo/b")
+
 	tests := []struct {
 		name     string
 		opts     model.Options
 		sessions []backend.Session
 		code     int
 		stopped  []string
 	}{
+		{
+			name:     "--name stops the matching session",
+			opts:     stopOptionsWithName("my-task"),
+			sessions: []backend.Session{mine, other},
+			stopped:  []string{mine.Ref.Name},
+		},
+		{
+			name:     "--name does not leave the project",
+			opts:     stopOptionsWithName("my-task"),
+			sessions: []backend.Session{foreign},
+		},
 		{
 			name:     "blank --name stops nothing",
 			opts:     stopOptionsWithName("   "),
-			sessions: sessions,
+			sessions: []backend.Session{mine, other},
 		},
 		{
 			name:     "unsanitizable --name stops nothing",
 			opts:     stopOptionsWithName("???"),
-			sessions: sessions,
+			sessions: []backend.Session{mine, other},
 		},
 		{
 			// The single session would be auto-selected if the blank argument were
 			// read as "no argument".
 			name:     "blank positional argument is rejected",
 			opts:     stopOptionsWithArg("   "),
-			sessions: sessions[:1],
+			sessions: []backend.Session{mine},
 			code:     1,
 		},
 		{
-			name:     "no filter stops every background session",
+			name:     "without --name every background session is stopped",
 			opts:     model.Options{Sources: model.DefaultOptionSources()},
-			sessions: sessions,
-			stopped:  []string{sessions[0].Ref.Name, sessions[1].Ref.Name},
+			sessions: []backend.Session{mine, foreign},
+			stopped:  []string{mine.Ref.Name, foreign.Ref.Name},
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			be := &stopTestBackend{sessions: tt.sessions}
-			if code := stopSessions(context.Background(), be, tt.opts, ""); code != tt.code {
+			if code := stopSessions(context.Background(), be, tt.opts, projectDir); code != tt.code {
 				t.Fatalf("stopSessions() = %d, want %d", code, tt.code)
 			}
 			if !slices.Equal(be.stopped, tt.stopped) {

internal/app/session_target.go

@@ -23,10 +23,10 @@ import (
 // hex-looking session names keep working.
 const containerIDMinPrefix = 8
 
-// containerIDMaxLen is the length of a full container ID. Recorded IDs are
-// truncated, so a longer value is matched on its leading characters — but only
-// up to the length a real ID can have.
-const containerIDMaxLen = 64
+// containerIDFullLen is the length of a full container ID. Recorded IDs are
+// truncated, so only a value of exactly this length may extend one; anything
+// between is a prefix or nothing at all.
+const containerIDFullLen = 64
 
 // sessionTargetQuery describes how a positional container/session argument is
 // resolved to exactly one managed session.
@@ -49,7 +49,8 @@ type sessionTargetQuery struct {
 	// ProjectScopedNames rejects a session name that only matches outside the
 	// current project. `stop` sets it: removal is destructive and the
 	// auto-assigned names `1`, `2`, … collide across projects by construction,
-	// so another project's session needs its container name or ID.
+	// so another project's session needs its container name or ID. It requires
+	// Project to be set; without it no name resolves.
 	ProjectScopedNames bool
 	// BackgroundOnly restricts auto-selection to detached sessions, so that a
 	// bare `attach` cannot grab the TTY of a foreground session that a second
@@ -188,20 +189,29 @@ func projectSessions(sessions []backend.Session, project model.Project) (scoped
 			return sameWorktree, true
 		}
 	}
-	if hash := strings.TrimSpace(project.Hash); hash != "" {
-		var sameProject []backend.Session
-		for _, session := range sessions {
-			if strings.TrimSpace(session.ProjectHash) == hash {
-				sameProject = append(sameProject, session)
-			}
-		}
-		if len(sameProject) > 0 {
-			return sameProject, true
-		}
+	if sameProject := projectHashSessions(sessions, project.Hash); len(sameProject) > 0 {
+		return sameProject, true
 	}
 	return sessions, false
 }
 
+// projectHashSessions narrows sessions to one project. An unresolvable project
+// (empty hash) matches nothing, never everything, so that a name-filtered
+// command cannot silently widen to the whole host.
+func projectHashSessions(sessions []backend.Session, hash string) []backend.Session {
+	hash = strings.TrimSpace(hash)
+	if hash == "" {
+		return nil
+	}
+	var matches []backend.Session
+	for _, session := range sessions {
+		if strings.TrimSpace(session.ProjectHash) == hash {
+			matches = append(matches, session)
+		}
+	}
+	return matches
+}
+
 func sessionsForTool(sessions []backend.Session, tool string) []backend.Session {
 	tool = strings.TrimSpace(tool)
 	if tool == "" {
@@ -222,9 +232,10 @@ func sessionsForTool(sessions []backend.Session, tool string) []backend.Session
 // matched. All matches are returned so that an ambiguous prefix is reported
 // instead of resolved by listing order.
 func sessionsByContainerID(sessions []backend.Session, requested string) []backend.Session {
-	if len(requested) < containerIDMinPrefix || len(requested) > containerIDMaxLen || !isHexString(requested) {
+	if len(requested) < containerIDMinPrefix || len(requested) > containerIDFullLen || !isHexString(requested) {
 		return nil
 	}
+	full := len(requested) == containerIDFullLen
 	var matches []backend.Session
 	for _, session := range sessions {
 		id := strings.TrimSpace(session.Ref.ID)
@@ -233,7 +244,7 @@ func sessionsByContainerID(sessions []backend.Session, requested string) []backe
 		}
 		// Session IDs are truncated, so a full ID pasted from docker carries the
 		// one recorded here as its prefix.
-		if strings.HasPrefix(id, requested) || strings.HasPrefix(requested, id) {
+		if strings.HasPrefix(id, requested) || (full && strings.HasPrefix(requested, id)) {
 			matches = append(matches, session)
 		}
 	}

internal/app/session_target_test.go

@@ -245,7 +245,8 @@ func TestResolveSessionTargetResolvesContainerID(t *testing.T) {
 	target.Ref.ID = "3f2b1c0d4e5f"
 	be := &stopTestBackend{sessions: []backend.Session{target}}
 
-	for _, requested := range []string{"3f2b1c0d4e5f", "3f2b1c0d", "3f2b1c0d4e5f6a7b8c9d"} {
+	fullID := target.Ref.ID + strings.Repeat("a", containerIDFullLen-len(target.Ref.ID))
+	for _, requested := range []string{"3f2b1c0d4e5f", "3f2b1c0d", fullID} {
 		got, err := resolveSessionTarget(context.Background(), be, sessionTargetQuery{Args: []string{requested}})
 		if err != nil {
 			t.Fatalf("resolveSessionTarget(%q) error = %v", requested, err)
@@ -274,14 +275,17 @@ func TestResolveSessionTargetReportsAmbiguousContainerIDPrefix(t *testing.T) {
 	}
 }
 
-func TestResolveSessionTargetRejectsOverlongContainerID(t *testing.T) {
+func TestResolveSessionTargetRejectsPartialContainerIDExtension(t *testing.T) {
 	target := session("enclave-claude-aaaaaaaaaaaa-my-task", "my-task", "aaaaaaaaaaaa", "/repo/a")
 	target.Ref.ID = "3f2b1c0d4e5f"
 	be := &stopTestBackend{sessions: []backend.Session{target}}
 
-	requested := target.Ref.ID + strings.Repeat("a", containerIDMaxLen)
-	if _, err := resolveSessionTarget(context.Background(), be, sessionTargetQuery{Args: []string{requested}}); err == nil {
-		t.Fatal("a value longer than a container ID must not match on its prefix")
+	// Only a complete ID may extend the recorded (truncated) one; a value of
+	// some length in between cannot be verified against it.
+	for _, requested := range []string{target.Ref.ID + "aaaaaaaa", target.Ref.ID + strings.Repeat("a", containerIDFullLen)} {
+		if _, err := resolveSessionTarget(context.Background(), be, sessionTargetQuery{Args: []string{requested}}); err == nil {
+			t.Fatalf("resolveSessionTarget(%q) must not match on the recorded ID prefix", requested)
+		}
 	}
 }
 

internal/cli/stop_command.go

@@ -19,8 +19,9 @@ With an argument, exactly the session it names is removed: a container name from
 ` + "`enclave ps`" + `, a container ID, or a session name of the current project.
 A session name of another project is not accepted here — pass its container name.
 
-Without an argument, every background container of the selected tool is removed;
---name narrows that to sessions with a matching name.`,
+Without an argument, every background container of the selected tool is removed,
+across all projects; --name narrows that to matching sessions of the current
+project.`,
 		Args: cobra.MaximumNArgs(1),
 		RunE: func(_ *cobra.Command, cmdArgs []string) error {
 			res.Action = "stop"