@@ -163,12 +163,12 @@ func buildImageWithSpinner(configDir string, noCache bool, label string) error {
 	var buf bytes.Buffer
 	var out io.Writer = &buf
 	if ux.Verbose {
-		out = io.MultiWriter(os.Stdout, &buf)
+		out = os.Stdout
 	}
 	sp := ux.NewProgressSpinner(label)
-	if err := runner.BuildImage(configDir, noCache, out); err != nil {
+	if err := runner.BuildImage(configDir, noCache, ux.Verbose, out); err != nil {
 		sp.Fail(label + " failed")
-		if !ux.Verbose {
+		if !ux.Verbose && buf.Len() > 0 {
 			fmt.Fprint(os.Stderr, buf.String())
 		}
 		return err
 
@@ -6,9 +6,11 @@ import (
 	"os"
 	"os/exec"
 	"runtime"
+	"strings"
 
 	"github.com/DimmKirr/devcell/internal/config"
 	internalvnc "github.com/DimmKirr/devcell/internal/vnc"
+	"github.com/DimmKirr/devcell/internal/ux"
 	"github.com/spf13/cobra"
 )
 
@@ -21,9 +23,16 @@ var vncCmd = &cobra.Command{
 func init() {
 	vncCmd.Flags().Bool("list", false, "list all running cell containers and their VNC ports")
 	vncCmd.Flags().String("app", "", "open VNC to a named container (by AppName)")
+	vncCmd.Flags().Bool("verbose", false, "show debug info for VNC port lookup")
 }
 
 func runVNC(cmd *cobra.Command, _ []string) error {
+	applyOutputFlags()
+	verbose, _ := cmd.Flags().GetBool("verbose")
+	if verbose {
+		ux.Verbose = true
+		ux.LogPlainText = true
+	}
 	list, _ := cmd.Flags().GetBool("list")
 	appName, _ := cmd.Flags().GetString("app")
 
@@ -37,12 +46,95 @@ func runVNC(cmd *cobra.Command, _ []string) error {
 }
 
 func vncDefault() error {
+	// Fast path: EXT_VNC_PORT is injected at container start with the correct
+	// published host port. When set, we're inside a devcell container and can
+	// use it directly without any docker lookup.
+	if port := os.Getenv("EXT_VNC_PORT"); port != "" {
+		vncDebug("EXT_VNC_PORT=%s (fast path)", port)
+		return openURL(internalvnc.VNCUrl(port))
+	}
+
 	c, err := config.LoadFromOS()
 	if err != nil {
 		return err
 	}
-	url := internalvnc.VNCUrl(c.VNCPort)
-	return openURL(url)
+	vncDebug("basedir: %s", c.BaseDir)
+	vncDebug("cellID:  %s  (computed port: %s)", c.CellID, c.VNCPort)
+
+	// --- Strategy 1: exact label match (containers started with current code) ---
+	// Filter by both basedir AND cellid for an exact session match.
+	out, err := exec.Command("docker", "ps",
+		"--filter", "label=devcell.basedir="+c.BaseDir,
+		"--filter", "label=devcell.cellid="+c.CellID,
+		"--format", "{{.Names}}\t{{.Ports}}").Output()
+	if err == nil {
+		vncDebug("label-exact docker ps output: %q", strings.TrimSpace(string(out)))
+		if m, _ := internalvnc.ParseDockerPS(string(bytes.TrimSpace(out))); len(m) > 0 {
+			for appName, port := range m {
+				vncDebug("label-exact match: %s → %s", appName, port)
+				return openURL(internalvnc.VNCUrl(port))
+			}
+		}
+	}
+
+	// --- Strategy 2: basedir-only label match (different session, same dir) ---
+	out, err = exec.Command("docker", "ps",
+		"--filter", "label=devcell.basedir="+c.BaseDir,
+		"--format", "{{.Names}}\t{{.Ports}}").Output()
+	if err == nil {
+		vncDebug("label-dir docker ps output: %q", strings.TrimSpace(string(out)))
+		if m, _ := internalvnc.ParseDockerPS(string(bytes.TrimSpace(out))); len(m) > 0 {
+			if len(m) == 1 {
+				for appName, port := range m {
+					vncDebug("label-dir single match: %s → %s", appName, port)
+					return openURL(internalvnc.VNCUrl(port))
+				}
+			}
+			// Multiple sessions — list options.
+			var opts []string
+			for appName := range m {
+				opts = append(opts, "  cell vnc --app "+appName)
+			}
+			return fmt.Errorf("multiple containers for this directory — pick one:\n%s", strings.Join(opts, "\n"))
+		}
+	}
+
+	// --- Strategy 3: bind-mount fallback (containers started before labels were added) ---
+	vncDebug("no label match; falling back to bind-mount inspect")
+	allOut, err := exec.Command("docker", "ps", "-q", "--filter", "name=cell-").Output()
+	if err != nil || len(bytes.TrimSpace(allOut)) == 0 {
+		return fmt.Errorf("no running container found for %q — run 'cell vnc --list' to see all", c.BaseDir)
+	}
+	ids := strings.Fields(string(bytes.TrimSpace(allOut)))
+	vncDebug("inspecting %d containers: %v", len(ids), ids)
+	inspectOut, err := exec.Command("docker", append([]string{"inspect"}, ids...)...).Output()
+	if err != nil {
+		return fmt.Errorf("docker inspect: %w", err)
+	}
+	matches, err := internalvnc.FindContainersByBind(string(inspectOut), c.BaseDir)
+	if err != nil {
+		return fmt.Errorf("parse inspect: %w", err)
+	}
+	vncDebug("bind-mount matches: %+v", matches)
+	switch len(matches) {
+	case 0:
+		return fmt.Errorf("no running container found for %q — run 'cell vnc --list' to see all", c.BaseDir)
+	case 1:
+		return openURL(internalvnc.VNCUrl(matches[0].Port))
+	default:
+		var opts []string
+		for _, m := range matches {
+			opts = append(opts, "  cell vnc --app "+m.AppName)
+		}
+		return fmt.Errorf("multiple containers for this directory — pick one:\n%s", strings.Join(opts, "\n"))
+	}
+}
+
+// vncDebug prints a debug line when --verbose is active.
+func vncDebug(format string, args ...any) {
+	if ux.Verbose {
+		fmt.Fprintf(os.Stderr, "[vnc] "+format+"\n", args...)
+	}
 }
 
 func vncList() error {
 
@@ -8,6 +8,7 @@ import (
 	"os/exec"
 	"path/filepath"
 	"strings"
+	"syscall"
 
 	"github.com/DimmKirr/devcell/internal/cfg"
 	"github.com/DimmKirr/devcell/internal/config"
@@ -59,6 +60,10 @@ func BuildArgv(spec RunSpec, fs FS, lookPath func(string) (string, error)) []str
 	argv = append(argv, "--user", "0")
 	argv = append(argv, "--group-add", "0")
 
+	// Labels for VNC lookup: filter by basedir+cellid without inspecting all containers
+	argv = append(argv, "--label", "devcell.basedir="+c.BaseDir)
+	argv = append(argv, "--label", "devcell.cellid="+c.CellID)
+
 	// Core env vars
 	e := func(k, v string) { argv = append(argv, "-e", k+"="+v) }
 	e("APP_NAME", c.AppName)
@@ -99,6 +104,7 @@ func BuildArgv(spec RunSpec, fs FS, lookPath func(string) (string, error)) []str
 
 	// Standard volumes
 	v := func(mount string) { argv = append(argv, "-v", mount) }
+	v(c.BaseDir + ":" + c.BaseDir)
 	v(c.BaseDir + ":/" + c.AppName)
 	v(c.CellHome + ":/home/" + c.HostUser)
 	v("/var/run/docker.sock:/var/run/docker.sock")
@@ -159,16 +165,32 @@ func EnsureNetwork(ctx context.Context) error {
 }
 
 // BuildImage runs docker build to build devcell-local from configDir.
-// Output is written to out; pass os.Stdout to stream, or a bytes.Buffer to capture.
-func BuildImage(configDir string, noCache bool, out io.Writer) error {
-	args := []string{"build", "-t", "devcell-local"}
+// verbose=true streams plain-text output to out; verbose=false suppresses all
+// docker output (quiet mode) and captures stderr to out for error replay.
+func BuildImage(configDir string, noCache bool, verbose bool, out io.Writer) error {
+	progress := "--progress=quiet"
+	if verbose {
+		progress = "--progress=plain"
+	}
+	args := []string{"build", "-t", "devcell-local", progress}
 	if noCache {
 		args = append(args, "--no-cache")
 	}
 	args = append(args, configDir)
 	cmd := exec.Command("docker", args...)
-	cmd.Stdout = out
-	cmd.Stderr = out
+	// Detach from the controlling TTY so Docker Desktop's BuildKit progress
+	// writer cannot open /dev/tty and write directly to the terminal.
+	cmd.SysProcAttr = &syscall.SysProcAttr{Setsid: true}
+	if verbose {
+		cmd.Stdout = out
+		cmd.Stderr = out
+	} else {
+		// Suppress progress output; capture stderr so we can replay it on failure.
+		cmd.Stdout = io.Discard
+		cmd.Stderr = out
+		// Belt-and-suspenders: also tell BuildKit via env to use quiet mode.
+		cmd.Env = append(os.Environ(), "BUILDKIT_PROGRESS=quiet")
+	}
 	if err := cmd.Run(); err != nil {
 		return fmt.Errorf("docker build: %w", err)
 	}
 
@@ -147,6 +147,18 @@ func TestArgv_UserAndGroupAdd(t *testing.T) {
 	}
 }
 
+// --- labels ---
+
+func TestArgv_Labels(t *testing.T) {
+	argv := buildArgv(t)
+	if !hasConsecutive(argv, "--label", "devcell.basedir=/home/bob/myproject") {
+		t.Errorf("missing --label devcell.basedir in argv: %v", argv)
+	}
+	if !hasConsecutive(argv, "--label", "devcell.cellid=3") {
+		t.Errorf("missing --label devcell.cellid in argv: %v", argv)
+	}
+}
+
 // --- env-file ---
 
 func TestArgv_EnvFilePresent(t *testing.T) {
 
@@ -26,9 +26,9 @@ func NewProgressSpinner(message string) *ProgressSpinner {
 	ps := &ProgressSpinner{msg: message}
 	if !LogPlainText {
 		s := pterm.DefaultSpinner
-		s.Sequence = []string{" ⡀ ", " ⢀ ", " ⠄ ", " ⠠ ", " ⠐ ", " ⠂ ", " ⠁ ", " ⠈ ", "   ", "   "}
+		s.Sequence = []string{" ⠋ ", " ⠙ ", " ⠹ ", " ⠸ ", " ⠼ ", " ⠴ ", " ⠦ ", " ⠧ ", " ⠇ ", " ⠏ "}
 		s.Style = pterm.NewStyle(pterm.FgLightBlue)
-		s.Delay = 150 * time.Millisecond
+		s.Delay = 80 * time.Millisecond
 		ps.spinner, _ = s.Start(message)
 	} else {
 		pterm.Info.Println(message)
 
@@ -6,6 +6,67 @@ import (
 	"strings"
 )
 
+// ContainerMatch holds data about a container matching a host-dir bind mount.
+type ContainerMatch struct {
+	Name    string // full container name, e.g. "cell-devcell-73-run"
+	AppName string // stripped name, e.g. "devcell-73"
+	Port    string // VNC host port
+}
+
+// fullInspectResult is the structure decoded from docker inspect JSON.
+type fullInspectResult struct {
+	Name       string `json:"Name"`
+	HostConfig struct {
+		Binds []string `json:"Binds"`
+	} `json:"HostConfig"`
+	NetworkSettings struct {
+		Ports map[string][]struct {
+			HostIp   string `json:"HostIp"`
+			HostPort string `json:"HostPort"`
+		} `json:"Ports"`
+	} `json:"NetworkSettings"`
+}
+
+// FindContainersByBind parses docker inspect JSON (one or many containers)
+// and returns all that have hostDir as the source of a bind mount and have
+// port 5900 published.
+func FindContainersByBind(inspectJSON, hostDir string) ([]ContainerMatch, error) {
+	var results []fullInspectResult
+	if err := json.Unmarshal([]byte(inspectJSON), &results); err != nil {
+		return nil, fmt.Errorf("parse inspect JSON: %w", err)
+	}
+	var matches []ContainerMatch
+	for _, r := range results {
+		if !hasBindSource(r.HostConfig.Binds, hostDir) {
+			continue
+		}
+		bindings, ok := r.NetworkSettings.Ports["5900/tcp"]
+		if !ok || len(bindings) == 0 {
+			continue
+		}
+		name := strings.TrimPrefix(r.Name, "/")
+		appName := strings.TrimPrefix(name, "cell-")
+		appName = strings.TrimSuffix(appName, "-run")
+		matches = append(matches, ContainerMatch{
+			Name:    name,
+			AppName: appName,
+			Port:    bindings[0].HostPort,
+		})
+	}
+	return matches, nil
+}
+
+// hasBindSource reports whether any bind in the list starts with "hostDir:".
+func hasBindSource(binds []string, hostDir string) bool {
+	prefix := hostDir + ":"
+	for _, b := range binds {
+		if strings.HasPrefix(b, prefix) {
+			return true
+		}
+	}
+	return false
+}
+
 // VNCUrl returns a VNC URL for the given port.
 func VNCUrl(port string) string {
 	return "vnc://:vnc@127.0.0.1:" + port
 
@@ -79,3 +79,44 @@ func TestParseInspectPort_Missing(t *testing.T) {
 		t.Error("expected error for missing 5900 port binding")
 	}
 }
+
+// TestParseDockerPS_DirPortMismatch covers the case where a container was
+// started from pane %3 (port 7350) but cell vnc is run from pane %11 (port
+// 1150). The lookup must return the actual docker port (7350), not the
+// env-computed one (1150).
+func TestParseDockerPS_DirPortMismatch(t *testing.T) {
+	// Simulate: container started with cellID=3, SESSION_PORT_PREFIX=7
+	// Container name: cell-devcell-73-3-run, VNC host port: 7350
+	// Current pane: %11 → computed port would be 1150 (wrong)
+	dockerPSOutput := "cell-devcell-73-3-run\t0.0.0.0:7350->5900/tcp"
+	m, err := vnc.ParseDockerPS(dockerPSOutput)
+	if err != nil {
+		t.Fatal(err)
+	}
+	got, ok := m["devcell-73-3"]
+	if !ok {
+		t.Fatalf("expected entry for devcell-73-3, got %v", m)
+	}
+	if got != "7350" {
+		t.Errorf("want actual port 7350, got %q (env-computed would be 1150)", got)
+	}
+}
+
+// TestParseDockerPS_MultiSession ensures that when multiple sessions of the
+// same directory exist, all ports are returned (caller picks one).
+func TestParseDockerPS_MultiSession(t *testing.T) {
+	output := "cell-devcell-73-3-run\t0.0.0.0:7350->5900/tcp\ncell-devcell-73-5-run\t0.0.0.0:7550->5900/tcp"
+	m, err := vnc.ParseDockerPS(output)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(m) != 2 {
+		t.Errorf("expected 2 entries, got %d: %v", len(m), m)
+	}
+	if m["devcell-73-3"] != "7350" {
+		t.Errorf("want devcell-73-3→7350, got %v", m)
+	}
+	if m["devcell-73-5"] != "7550" {
+		t.Errorf("want devcell-73-5→7550, got %v", m)
+	}
+}