feat(init): adopt the model server that is actually running

`slmcode init` ended a first run with "no model server answered" and a pointer
at `slmcode doctor` — two more commands for somebody who has just scaffolded a
workspace, when a server is very often running on a port that is simply not the
default. That is the exact moment auto-configuration is worth the most and
costs the least: the config was written seconds ago from defaults, so there is
nothing of the user's to protect.

It now looks around and adopts what it finds, printing what it did. Two guards
keep that safe:

- Only when the configured endpoint did NOT answer, so a working setup is never
  moved.
- Never when the endpoint was pinned by --endpoint or SLMCODE_ENDPOINT. That is
  a statement about where the server is, and quietly configuring something else
  would be the tool arguing with the user.

When it finds nothing it says which of the three problems this is — nothing
listening, no models loaded, or no model that can write code — instead of the
generic remedy, because those have different fixes.

adoptDiscoveredServer takes a context rather than the cobra command: it needed
nothing else from it, and cmd.Context() is nil on a command that was never
executed, which made the function unsafe to call from anywhere but its one
call site.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UiLDxnEu1Gf8Q5hWAFhaAd

Author: claude

cmd/slmcode/cmd_core.go

@@ -15,6 +15,7 @@ import (
 
 	"github.com/spf13/cobra"
 
+	"github.com/UnicoLab/slmcode/pkg/autoconfig"
 	"github.com/UnicoLab/slmcode/pkg/blocks"
 	"github.com/UnicoLab/slmcode/pkg/cli"
 	"github.com/UnicoLab/slmcode/pkg/config"
@@ -107,6 +108,16 @@ Run ` + "`slmcode config show --all`" + ` to see the full effective surface.`,
 				ws.Config.Model, ws.Config.APIKey, 1500*time.Millisecond)
 			if probe.State == cli.ProbeDown {
 				fmt.Println(cli.Warn("no model server answered at " + ws.Config.Endpoint))
+				// This is the moment auto-configuration is worth the most and
+				// costs the least: the config was written seconds ago from
+				// defaults, so there is nothing of the user's to protect, and
+				// the alternative is sending somebody who just scaffolded a
+				// workspace away to run two more commands. A server IS often
+				// running — on a different port from the default.
+				if adopted := adoptDiscoveredServer(cmd.Context(), ws.Config); adopted {
+					fmt.Println(cli.Info("next: slmcode run -v \"…\"  — agents fill context, plan, and tasks"))
+					return nil
+				}
 				if probe.Remedy != "" {
 					fmt.Println(cli.Dim("  " + probe.Remedy))
 				}
@@ -902,3 +913,51 @@ func boardProgress(slmDir string) func() (int, int) {
 func studioUIIsPlaceholder(uiFS fs.FS) bool {
 	return !server.UIIsBuilt(uiFS)
 }
+
+// adoptDiscoveredServer looks for a model server and writes what it finds.
+//
+// Only ever called when the configured endpoint did NOT answer, so it cannot
+// move a working setup. It also stands down when the user pinned an endpoint
+// themselves: `slmcode init --endpoint X` is a statement about where the server
+// is, and quietly configuring Y instead would be the tool arguing with them.
+//
+// Reports what it did either way. A command that silently rewrites the config
+// it just told you about is one you have to re-read afterwards.
+func adoptDiscoveredServer(ctx context.Context, cfg *config.Config) bool {
+	if flagEndpoint != "" || strings.TrimSpace(os.Getenv("SLMCODE_ENDPOINT")) != "" {
+		return false
+	}
+	fmt.Println(cli.Dim("  looking for one elsewhere…"))
+
+	ctx, cancel := context.WithTimeout(ctx, autoconfig.DefaultProbeTimeout+5*time.Second)
+	defer cancel()
+	res := autoconfig.Discover(ctx, cfg, os.Getenv,
+		autoconfig.HTTPProber(autoconfig.DefaultProbeTimeout))
+	if !res.Found {
+		// More specific than the generic remedy: it distinguishes nothing
+		// listening from a server with no models from a server whose models
+		// cannot write code, and those have different fixes.
+		fmt.Println(cli.Dim("  " + res.NothingFound()))
+		return false
+	}
+
+	choice := res.Choice
+	cfg.Provider = choice.Provider
+	cfg.Endpoint = choice.Endpoint
+	cfg.Model = choice.Model
+	cfg.ActiveStack = ""
+	cfg.Normalize()
+	saveKeys := []string{"provider", "model", "endpoint"}
+	if cfg.ActivePack != "" {
+		saveKeys = append(saveKeys, "active_pack")
+	}
+	if err := cfg.SaveInitial(saveKeys...); err != nil {
+		fmt.Println(cli.Warn("found " + choice.Endpoint + " but could not save: " + err.Error()))
+		return false
+	}
+	fmt.Println(cli.Success("found " + choice.Provider + " at " + choice.Endpoint))
+	cli.KeyVal("model", choice.Model)
+	cli.KeyVal("why", choice.Why)
+	fmt.Println(cli.Dim("  `slmcode configure` to change it, `slmcode config show` to see it"))
+	return true
+}

cmd/slmcode/cmd_init_adopt_test.go

@@ -0,0 +1,133 @@
+package main
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/UnicoLab/slmcode/pkg/config"
+	"github.com/UnicoLab/slmcode/pkg/orchestrator"
+)
+
+// `slmcode init` used to end a first run with "no model server answered" and a
+// pointer at `slmcode doctor` — two more commands for somebody who has just
+// scaffolded a workspace, when a server is often running on a port that is
+// simply not the default.
+
+func adoptWorkspace(t *testing.T) *config.Config {
+	t.Helper()
+	root := t.TempDir()
+	cfg := config.Default(root)
+	cfg.Root = root
+	if err := orchestrator.InitWorkspace(root, cfg); err != nil {
+		t.Fatal(err)
+	}
+	return cfg
+}
+
+func adoptServer(t *testing.T, ids ...string) *httptest.Server {
+	t.Helper()
+	body := `{"object":"list","data":[`
+	for i, id := range ids {
+		if i > 0 {
+			body += ","
+		}
+		body += `{"id":"` + id + `"}`
+	}
+	body += `]}`
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if !strings.HasSuffix(r.URL.Path, "/models") {
+			w.WriteHeader(http.StatusNotFound)
+			return
+		}
+		_, _ = w.Write([]byte(body))
+	}))
+	t.Cleanup(srv.Close)
+	return srv
+}
+
+func TestInitAdoptsAServerItFinds(t *testing.T) {
+	// adoptDiscoveredServer reads two globals that other tests in this package
+	// set; a stale one here would look like a bug in adoption.
+	prev := flagEndpoint
+	flagEndpoint = ""
+	t.Cleanup(func() { flagEndpoint = prev })
+	t.Setenv("SLMCODE_ENDPOINT", "")
+
+	cfg := adoptWorkspace(t)
+	srv := adoptServer(t, "nomic-embed-text", "Qwen2.5-Coder-14B-Instruct")
+	cfg.Endpoint = srv.URL + "/v1"
+
+	if !adoptDiscoveredServer(context.Background(), cfg) {
+		t.Fatalf("a live server must be adopted (endpoint=%q flagEndpoint=%q env=%q)",
+			cfg.Endpoint, flagEndpoint, os.Getenv("SLMCODE_ENDPOINT"))
+	}
+	if cfg.Model != "Qwen2.5-Coder-14B-Instruct" {
+		t.Errorf("model = %q, want the coder rather than the embedding model", cfg.Model)
+	}
+	// And it reaches disk, or the next command sees the old configuration.
+	reloaded, err := config.Load(cfg.Root)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if reloaded.Endpoint != srv.URL+"/v1" {
+		t.Errorf("saved endpoint = %q", reloaded.Endpoint)
+	}
+}
+
+// `slmcode init --endpoint X` is a statement about where the server is.
+// Quietly configuring Y instead would be the tool arguing with the user.
+func TestInitStandsDownWhenTheUserPinnedAnEndpoint(t *testing.T) {
+	cfg := adoptWorkspace(t)
+	srv := adoptServer(t, "Qwen2.5-Coder-14B-Instruct")
+	cfg.Endpoint = srv.URL + "/v1"
+
+	prev := flagEndpoint
+	flagEndpoint = "http://127.0.0.1:9999/v1"
+	t.Cleanup(func() { flagEndpoint = prev })
+
+	if adoptDiscoveredServer(context.Background(), cfg) {
+		t.Error("a pinned endpoint must not be replaced by a discovered one")
+	}
+}
+
+func TestInitStandsDownWhenTheEnvironmentPinnedAnEndpoint(t *testing.T) {
+	cfg := adoptWorkspace(t)
+	srv := adoptServer(t, "Qwen2.5-Coder-14B-Instruct")
+	cfg.Endpoint = srv.URL + "/v1"
+	t.Setenv("SLMCODE_ENDPOINT", "http://127.0.0.1:9999/v1")
+
+	if adoptDiscoveredServer(context.Background(), cfg) {
+		t.Error("an endpoint pinned in the environment must not be replaced")
+	}
+}
+
+// A server whose models cannot write code is not something to adopt, and
+// saying so beats writing a config whose first run fails.
+//
+// Asserts that THIS server was not adopted rather than that nothing was: a
+// developer running LM Studio while the suite runs has a real second candidate,
+// and adopting it would be correct. A test that fails on a machine with a model
+// server running is a test nobody trusts.
+func TestInitDoesNotAdoptAServerWithNothingUsable(t *testing.T) {
+	prev := flagEndpoint
+	flagEndpoint = ""
+	t.Cleanup(func() { flagEndpoint = prev })
+	t.Setenv("SLMCODE_ENDPOINT", "")
+
+	cfg := adoptWorkspace(t)
+	srv := adoptServer(t, "nomic-embed-text", "whisper-large-v3")
+	cfg.Endpoint = srv.URL + "/v1"
+
+	adoptDiscoveredServer(context.Background(), cfg)
+	if cfg.Endpoint == srv.URL+"/v1" && cfg.Model != "" {
+		for _, bad := range []string{"nomic-embed-text", "whisper-large-v3"} {
+			if cfg.Model == bad {
+				t.Errorf("adopted %q, which cannot write code", bad)
+			}
+		}
+	}
+}

docs/changelog.md

@@ -331,6 +331,13 @@ because they have different fixes. And it is now the remedy named when a run
 refuses to start because the endpoint is down or the configured model is not
 served, which is where somebody actually needs it.
 
+`slmcode init` runs it for you. It used to end a first run with "no model server
+answered" and a pointer at `slmcode doctor` — two more commands for somebody who
+has just scaffolded a workspace, when a server is often running on a port that
+is simply not the default. It now looks around and adopts what it finds. Only
+when the configured endpoint did not answer, so it can never move a working
+setup, and never when you pinned `--endpoint` or `SLMCODE_ENDPOINT`.
+
 ### Added — correction tickets are legible on the board
 
 A correction ticket looked exactly like planned work: same card, same badges, a

docs/cli.md

@@ -372,6 +372,26 @@ because the endpoint is down or the configured model is not served. In the
 Studio it is the **Find my model server** panel in Settings, with the same two
 steps: *Look around* changes nothing, *Configure for me* writes.
 
+### It runs itself on `init`
+
+`slmcode init` used to end with "no model server answered" and a pointer at
+`slmcode doctor` — two more commands for somebody who has just scaffolded a
+workspace, when a server is often running on a port that is simply not the
+default. It now looks around and adopts what it finds:
+
+```text
+⚠ no model server answered at http://127.0.0.1:8000/v1
+  looking for one elsewhere…
+✔ found lmstudio at http://127.0.0.1:1234/v1
+  model           Qwen3-Coder-30B-A3B-Instruct-MLX-4bit
+  why             tuned for code (coder), instruction-tuned, 30B, 3B active
+```
+
+Only when the configured endpoint did **not** answer, so it can never move a
+working setup, and never when you pinned `--endpoint` or `SLMCODE_ENDPOINT` —
+that is a statement about where the server is, and configuring something else
+would be the tool arguing with you.
+
 ---
 
 ## `compose`