From f9cbbd7308c66646be31befbbc4516c5010b178d Mon Sep 17 00:00:00 2001
From: Samuel K <skevetter@pm.me>
Date: Sat, 1 Aug 2026 13:40:40 -0500
Subject: [PATCH 1/5] feat(provider): add initializing/failed states to
 provider init lifecycle

Provider init previously only tracked a persisted Initialized bool, so the
UI/CLI/MCP tool couldn't distinguish "in progress" or "crashed/failed" from
"never started" while a provider's init command ran. Adds a cross-process
tri-state (not_initialized/initializing/initialized/failed) derived from an
advisory file lock held for the duration of Exec.Init, so a crashed process
self-heals to "failed" instead of silently reverting.
---
 cmd/mcp/tools_provider.go                     |  2 +
 cmd/provider/configure_shared.go              | 65 +++++++++++---
 cmd/provider/list.go                          |  4 +-
 desktop/src/main/watcher.ts                   |  2 +
 .../components/provider/ProviderCard.svelte   | 14 +--
 .../components/provider/ProviderCard.test.ts  | 36 +++++---
 .../components/provider/ProviderSheet.svelte  | 16 ++--
 .../components/provider/ProviderSheet.test.ts |  4 +-
 .../components/provider/ProviderWizard.svelte |  9 +-
 .../src/renderer/src/lib/stores/providers.ts  | 17 ----
 desktop/src/renderer/src/lib/types/index.ts   |  3 +
 pkg/config/config.go                          | 13 +++
 pkg/provider/initlock.go                      | 68 +++++++++++++++
 pkg/provider/initlock_test.go                 | 86 +++++++++++++++++++
 pkg/workspace/provider.go                     | 19 ++++
 15 files changed, 290 insertions(+), 68 deletions(-)
 create mode 100644 pkg/provider/initlock.go
 create mode 100644 pkg/provider/initlock_test.go

diff --git a/cmd/mcp/tools_provider.go b/cmd/mcp/tools_provider.go
index d68c56dd2..363b533f2 100644
--- a/cmd/mcp/tools_provider.go
+++ b/cmd/mcp/tools_provider.go
@@ -16,6 +16,7 @@ type providerSummary struct {
 	Name    string `json:"name"`
 	Version string `json:"version,omitempty"`
 	Default bool   `json:"default,omitempty"`
+	Status  string `json:"status,omitempty"`
 }
 
 type providerListOutput struct {
@@ -108,6 +109,7 @@ func handleProviderList(_ context.Context, g *flags.GlobalFlags) (providerListOu
 			Name:    entry.Config.Name,
 			Version: entry.Config.Version,
 			Default: entry.Config.Name == defaultProvider,
+			Status:  string(entry.Status),
 		})
 	}
 	sort.Slice(summaries, func(i, j int) bool {
diff --git a/cmd/provider/configure_shared.go b/cmd/provider/configure_shared.go
index 14539f7c1..e90d943d9 100644
--- a/cmd/provider/configure_shared.go
+++ b/cmd/provider/configure_shared.go
@@ -164,7 +164,37 @@ func initProvider(
 	provider *provider2.ProviderConfig,
 	io2 initIO,
 ) error {
-	err := clientimplementation.RunCommandWithBinaries(clientimplementation.CommandOptions{
+	lock, err := provider2.GetProviderInitLock(devsyConfig.DefaultContext, provider.Name)
+	if err != nil {
+		return fmt.Errorf("get init lock: %w", err)
+	}
+	locked, err := lock.TryLock()
+	if err != nil {
+		return fmt.Errorf("lock provider init: %w", err)
+	}
+	if !locked {
+		return fmt.Errorf("provider %q is already being initialized", provider.Name)
+	}
+	defer func() { _ = lock.Unlock() }()
+
+	if devsyConfig.Current().Providers == nil {
+		devsyConfig.Current().Providers = map[string]*config.ProviderConfig{}
+	}
+	if devsyConfig.Current().Providers[provider.Name] == nil {
+		devsyConfig.Current().Providers[provider.Name] = &config.ProviderConfig{}
+	}
+	entry := devsyConfig.Current().Providers[provider.Name]
+
+	// Persist immediately so a concurrent `provider list` sees "initializing"
+	// for the duration of Exec.Init rather than waiting for the caller's final
+	// save at the end of ConfigureProvider.
+	entry.InitAttempted = true
+	entry.InitError = ""
+	if err := config.SaveConfig(devsyConfig); err != nil {
+		return fmt.Errorf("save init state: %w", err)
+	}
+
+	runErr := clientimplementation.RunCommandWithBinaries(clientimplementation.CommandOptions{
 		Ctx:     ctx,
 		Command: provider.Exec.Init,
 		Context: devsyConfig.DefaultContext,
@@ -173,15 +203,30 @@ func initProvider(
 		Stdout:  io2.stdout,
 		Stderr:  io2.stderr,
 	})
-	if err != nil {
-		return fmt.Errorf("init: %w", err)
-	}
-	if devsyConfig.Current().Providers == nil {
-		devsyConfig.Current().Providers = map[string]*config.ProviderConfig{}
-	}
-	if devsyConfig.Current().Providers[provider.Name] == nil {
-		devsyConfig.Current().Providers[provider.Name] = &config.ProviderConfig{}
+	if runErr != nil {
+		entry.InitError = truncateInitError(runErr.Error())
+		// Best-effort: InitAttempted is already durably true from the save
+		// above, so ResolveInitState still reports "failed" once the deferred
+		// unlock releases the init lock even if this save fails; only the
+		// diagnostic InitError message would be lost.
+		if saveErr := config.SaveConfig(devsyConfig); saveErr != nil {
+			log.Warnf("save init failure state for provider %s: %v", provider.Name, saveErr)
+		}
+		return fmt.Errorf("init: %w", runErr)
 	}
-	devsyConfig.Current().Providers[provider.Name].Initialized = true
+
+	entry.Initialized = true
 	return nil
 }
+
+// maxInitErrorLen bounds how much of a failed init command's error we persist
+// to config.json, which (unlike interactive CLI/log output) may be synced,
+// backed up, or included in support bundles.
+const maxInitErrorLen = 500
+
+func truncateInitError(msg string) string {
+	if len(msg) <= maxInitErrorLen {
+		return msg
+	}
+	return msg[:maxInitErrorLen] + "…"
+}
diff --git a/cmd/provider/list.go b/cmd/provider/list.go
index 0ef443321..6635b303a 100644
--- a/cmd/provider/list.go
+++ b/cmd/provider/list.go
@@ -115,7 +115,7 @@ func (cmd *ListCmd) renderInstalledPlain(
 			entry.Config.Name,
 			entry.Config.Version,
 			strconv.FormatBool(devsyConfig.Current().DefaultProvider == entry.Config.Name),
-			strconv.FormatBool(entry.State != nil && entry.State.Initialized),
+			string(entry.Status),
 			entry.Config.Description,
 		})
 	}
@@ -127,7 +127,7 @@ func (cmd *ListCmd) renderInstalledPlain(
 		"Name",
 		"Version",
 		"Default",
-		"Initialized",
+		"Status",
 		"Description",
 	}, tableEntries)
 
diff --git a/desktop/src/main/watcher.ts b/desktop/src/main/watcher.ts
index b698f9db7..107378492 100644
--- a/desktop/src/main/watcher.ts
+++ b/desktop/src/main/watcher.ts
@@ -30,6 +30,7 @@ export interface ProviderEntry {
     optionGroups?: unknown[]
   }
   state?: { initialized?: boolean; singleMachine?: boolean }
+  status?: string
   default?: boolean
 }
 
@@ -43,6 +44,7 @@ export function parseProviderEntries(raw: Record<string, ProviderEntry>) {
     options: entry.config.options ?? {},
     optionGroups: entry.config.optionGroups ?? [],
     isDefault: entry.default ?? false,
+    status: entry.status ?? "not_initialized",
     state: {
       initialized: entry.state?.initialized ?? false,
       singleMachine: entry.state?.singleMachine ?? false,
diff --git a/desktop/src/renderer/src/lib/components/provider/ProviderCard.svelte b/desktop/src/renderer/src/lib/components/provider/ProviderCard.svelte
index aa7a06572..a67a448da 100644
--- a/desktop/src/renderer/src/lib/components/provider/ProviderCard.svelte
+++ b/desktop/src/renderer/src/lib/components/provider/ProviderCard.svelte
@@ -1,15 +1,12 @@
 <script lang="ts">
 import { badgeVariants } from "$lib/components/ui/badge/index.js"
-import { Star, Loader2 } from "@lucide/svelte"
+import { Star, Loader2, AlertTriangle } from "@lucide/svelte"
 import ProviderIcon from "./ProviderIcon.svelte"
 import { providerVersions } from "$lib/stores/providerVersions.js"
-import { initializingProviders } from "$lib/stores/providers.js"
 import type { Provider } from "$lib/types/index.js"
 
 let { provider, onopen }: { provider: Provider; onopen?: () => void } = $props()
 
-let isInitializing = $derived($initializingProviders.has(provider.name))
-
 function sourceDisplay(p: Provider): string {
   if (p.source?.github) return p.source.github
   if (p.source?.url) return p.source.url
@@ -41,13 +38,18 @@ function sourceDisplay(p: Provider): string {
       {/if}
     </div>
     <div class="flex gap-1.5 shrink-0">
-      {#if provider.state?.initialized}
+      {#if provider.status === "initialized"}
         <span class={badgeVariants({ variant: "secondary" })}>initialized</span>
-      {:else if isInitializing}
+      {:else if provider.status === "initializing"}
         <span class="{badgeVariants({ variant: 'outline' })} gap-1">
           <Loader2 class="size-3 animate-spin" />
           initializing…
         </span>
+      {:else if provider.status === "failed"}
+        <span class="{badgeVariants({ variant: 'destructive' })} gap-1">
+          <AlertTriangle class="size-3" />
+          failed
+        </span>
       {:else}
         <span class={badgeVariants({ variant: "destructive" })}>not initialized</span>
       {/if}
diff --git a/desktop/src/renderer/src/lib/components/provider/ProviderCard.test.ts b/desktop/src/renderer/src/lib/components/provider/ProviderCard.test.ts
index 6e47be242..4f599e570 100644
--- a/desktop/src/renderer/src/lib/components/provider/ProviderCard.test.ts
+++ b/desktop/src/renderer/src/lib/components/provider/ProviderCard.test.ts
@@ -14,16 +14,12 @@ vi.mock("$lib/stores/providerVersions.js", async () => {
 })
 
 import ProviderCard from "./ProviderCard.svelte"
-import {
-  initializingProviders,
-  markInitializing,
-  clearInitializing,
-} from "$lib/stores/providers.js"
 
 function makeProvider(name: string, extras: Partial<Provider> = {}): Provider {
   return {
     name,
     version: "0.1.0",
+    status: "initialized",
     state: { initialized: true },
     ...extras,
   }
@@ -55,24 +51,38 @@ describe("ProviderCard", () => {
     unmount()
   })
 
-  it("shows the initializing badge while an uninitialized provider is in flight", () => {
-    initializingProviders.set(new Set())
-    markInitializing("ssh")
+  it("shows the initializing badge while status is initializing", () => {
     const { container, unmount } = render(ProviderCard, {
-      props: { provider: makeProvider("ssh", { state: { initialized: false } }) },
+      props: {
+        provider: makeProvider("ssh", { status: "initializing", state: { initialized: false } }),
+      },
     })
 
     const text = container.textContent ?? ""
     expect(text.toLowerCase()).toContain("initializing")
     expect(text.toLowerCase()).not.toContain("not initialized")
-    clearInitializing("ssh")
     unmount()
   })
 
-  it("shows not initialized when no init is in flight", () => {
-    initializingProviders.set(new Set())
+  it("shows the failed badge when status is failed", () => {
     const { container, unmount } = render(ProviderCard, {
-      props: { provider: makeProvider("ssh", { state: { initialized: false } }) },
+      props: {
+        provider: makeProvider("ssh", { status: "failed", state: { initialized: false } }),
+      },
+    })
+
+    expect((container.textContent ?? "").toLowerCase()).toContain("failed")
+    unmount()
+  })
+
+  it("shows not initialized when status is not_initialized", () => {
+    const { container, unmount } = render(ProviderCard, {
+      props: {
+        provider: makeProvider("ssh", {
+          status: "not_initialized",
+          state: { initialized: false },
+        }),
+      },
     })
 
     expect((container.textContent ?? "").toLowerCase()).toContain(
diff --git a/desktop/src/renderer/src/lib/components/provider/ProviderSheet.svelte b/desktop/src/renderer/src/lib/components/provider/ProviderSheet.svelte
index 5ae33b6da..35f3b166a 100644
--- a/desktop/src/renderer/src/lib/components/provider/ProviderSheet.svelte
+++ b/desktop/src/renderer/src/lib/components/provider/ProviderSheet.svelte
@@ -28,11 +28,7 @@ import {
   providerRename,
   providerSetVersion,
 } from "$lib/ipc/commands.js"
-import {
-  providers,
-  markInitializing,
-  clearInitializing,
-} from "$lib/stores/providers.js"
+import { providers } from "$lib/stores/providers.js"
 import {
   providerVersions,
   loadVersionsFor,
@@ -227,7 +223,6 @@ function extractCliError(err: unknown): CLIError | null {
 async function handleInitialize() {
   initializing = true
   initError = null
-  markInitializing(provider.name)
   try {
     await providerInit(provider.name)
     const updated = await providerList()
@@ -248,7 +243,6 @@ async function handleInitialize() {
     }
   } finally {
     initializing = false
-    clearInitializing(provider.name)
   }
 }
 
@@ -367,8 +361,12 @@ async function handleSaveOptions() {
             Default
           </span>
         {/if}
-        {#if provider.state?.initialized}
+        {#if provider.status === "initialized"}
           <span class={badgeVariants({ variant: "secondary" })}>initialized</span>
+        {:else if provider.status === "initializing"}
+          <span class={badgeVariants({ variant: "outline" })}>initializing…</span>
+        {:else if provider.status === "failed"}
+          <span class={badgeVariants({ variant: "destructive" })}>failed</span>
         {/if}
       </Sheet.Title>
       {#if provider.description}
@@ -377,7 +375,7 @@ async function handleSaveOptions() {
     </Sheet.Header>
 
     <div class="flex items-center gap-2 px-6">
-      {#if provider.state?.initialized !== true}
+      {#if provider.status !== "initialized" && provider.status !== "initializing"}
         <Button variant="outline" size="sm" onclick={handleInitialize} disabled={initializing}>
           {#if initializing}
             <Spinner class="mr-2 size-3" />
diff --git a/desktop/src/renderer/src/lib/components/provider/ProviderSheet.test.ts b/desktop/src/renderer/src/lib/components/provider/ProviderSheet.test.ts
index ef1be3f02..c8adb168e 100644
--- a/desktop/src/renderer/src/lib/components/provider/ProviderSheet.test.ts
+++ b/desktop/src/renderer/src/lib/components/provider/ProviderSheet.test.ts
@@ -31,9 +31,6 @@ vi.mock("$lib/stores/providers.js", async () => {
   const { writable } = await import("svelte/store")
   return {
     providers: writable([]),
-    initializingProviders: writable(new Set()),
-    markInitializing: vi.fn(),
-    clearInitializing: vi.fn(),
   }
 })
 
@@ -77,6 +74,7 @@ function makeProvider(name: string, extras: Partial<Provider> = {}): Provider {
   return {
     name,
     version: "0.1.0",
+    status: "initialized",
     state: { initialized: true },
     ...extras,
   }
diff --git a/desktop/src/renderer/src/lib/components/provider/ProviderWizard.svelte b/desktop/src/renderer/src/lib/components/provider/ProviderWizard.svelte
index 176c7156d..0167b761b 100644
--- a/desktop/src/renderer/src/lib/components/provider/ProviderWizard.svelte
+++ b/desktop/src/renderer/src/lib/components/provider/ProviderWizard.svelte
@@ -23,11 +23,7 @@ import {
   providerSetOptions,
 } from "$lib/ipc/commands.js"
 import { onCommandProgress } from "$lib/ipc/events.js"
-import {
-  providers,
-  markInitializing,
-  clearInitializing,
-} from "$lib/stores/providers.js"
+import { providers } from "$lib/stores/providers.js"
 import { toasts } from "$lib/stores/toasts.js"
 import { extractErrorMessage } from "$lib/utils/error.js"
 import { isCommandSuccess } from "$lib/utils/log-parser.js"
@@ -166,7 +162,6 @@ onMount(async () => {
       }
       if (progress.done) {
         initRunning = false
-        clearInitializing(providerName)
         if (isCommandSuccess(progress.message)) {
           refreshAndComplete()
         } else {
@@ -284,12 +279,10 @@ async function startInit() {
   initError = null
   initStartError = ""
   initLines = []
-  markInitializing(providerName)
   try {
     initCommandId = await providerInitStreaming(providerName)
   } catch (err) {
     initRunning = false
-    clearInitializing(providerName)
     initStartError = `Failed to start initialization: ${err instanceof Error ? err.message : String(err)}`
   }
 }
diff --git a/desktop/src/renderer/src/lib/stores/providers.ts b/desktop/src/renderer/src/lib/stores/providers.ts
index ba3fe9d8d..ba1d638e2 100644
--- a/desktop/src/renderer/src/lib/stores/providers.ts
+++ b/desktop/src/renderer/src/lib/stores/providers.ts
@@ -7,23 +7,6 @@ import type { Provider } from "$lib/types/index.js"
 export const providers = writable<Provider[]>([])
 export const providersLoading = writable(true)
 
-// Names of providers whose initialization is currently in flight. Lets cards
-// show an "initializing…" state instead of the red "not initialized" badge
-// during the multi-second init that runs after a provider is added.
-export const initializingProviders = writable<Set<string>>(new Set())
-
-export function markInitializing(name: string) {
-  initializingProviders.update((set) => new Set(set).add(name))
-}
-
-export function clearInitializing(name: string) {
-  initializingProviders.update((set) => {
-    const next = new Set(set)
-    next.delete(name)
-    return next
-  })
-}
-
 let unlisten: UnlistenFn | null = null
 
 export async function initProviders() {
diff --git a/desktop/src/renderer/src/lib/types/index.ts b/desktop/src/renderer/src/lib/types/index.ts
index 9808c1046..ae83899a0 100644
--- a/desktop/src/renderer/src/lib/types/index.ts
+++ b/desktop/src/renderer/src/lib/types/index.ts
@@ -67,6 +67,8 @@ export interface ProviderOption {
   group?: string
 }
 
+export type ProviderStatus = "not_initialized" | "initializing" | "initialized" | "failed"
+
 export interface Provider {
   name: string
   version?: string
@@ -75,6 +77,7 @@ export interface Provider {
   options?: Record<string, ProviderOption>
   optionGroups?: ProviderOptionGroup[]
   isDefault?: boolean
+  status?: ProviderStatus
   state?: {
     initialized?: boolean
     singleMachine?: boolean
diff --git a/pkg/config/config.go b/pkg/config/config.go
index 7ede6d0c9..e26d41594 100644
--- a/pkg/config/config.go
+++ b/pkg/config/config.go
@@ -73,6 +73,19 @@ type ProviderConfig struct {
 	// Initialized holds if the provider was initialized correctly.
 	Initialized bool `json:"initialized,omitempty"`
 
+	// InitAttempted holds if an initialization attempt has been started. Combined
+	// with the provider's init lock (see pkg/provider), this distinguishes "never
+	// initialized" from "an attempt started but didn't finish" (crashed or failed)
+	// when Initialized is false.
+	InitAttempted bool `json:"initAttempted,omitempty"`
+
+	// InitError holds the error from the last failed initialization attempt,
+	// truncated to a bounded length since it's persisted to config.json (which
+	// may be synced or bundled for support) rather than kept in transient log
+	// output. Empty if the last attempt succeeded, was never run, or was
+	// abandoned by a crashed process (in which case InitAttempted is still true).
+	InitError string `json:"initError,omitempty"`
+
 	// SingleMachine signals Devsy if a single machine should be used for this provider.
 	SingleMachine bool `json:"singleMachine,omitempty"`
 
diff --git a/pkg/provider/initlock.go b/pkg/provider/initlock.go
new file mode 100644
index 000000000..f545c4c54
--- /dev/null
+++ b/pkg/provider/initlock.go
@@ -0,0 +1,68 @@
+package provider
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/devsy-org/devsy/pkg/config"
+	"github.com/gofrs/flock"
+)
+
+// InitState is the lifecycle state of a provider's initialization.
+type InitState string
+
+const (
+	InitStateNotInitialized InitState = "not_initialized"
+	InitStateInitializing   InitState = "initializing"
+	InitStateInitialized    InitState = "initialized"
+	InitStateFailed         InitState = "failed"
+)
+
+// GetProviderInitLock returns the advisory lock used to signal that a
+// provider's init command is currently running. Held for the duration of
+// Exec.Init in initProvider; ResolveInitState probes it (without blocking) to
+// tell a live "initializing" run apart from one abandoned by a crashed
+// process, since the OS releases the lock the moment that process dies.
+func GetProviderInitLock(contextName, name string) (*flock.Flock, error) {
+	locksDir, err := GetLocksDir(contextName)
+	if err != nil {
+		return nil, fmt.Errorf("get locks dir: %w", err)
+	}
+	// #nosec G301 -- mirrors existing lock dir permissions elsewhere in this package
+	if err := os.MkdirAll(locksDir, 0o755); err != nil {
+		return nil, fmt.Errorf("create locks dir: %w", err)
+	}
+
+	return flock.New(filepath.Join(locksDir, name+".provider-init.lock")), nil
+}
+
+// ResolveInitState derives the current init lifecycle state for a provider
+// from its persisted config and the live state of its init lock.
+func ResolveInitState(contextName, name string, state *config.ProviderConfig) (InitState, error) {
+	if state != nil && state.Initialized {
+		return InitStateInitialized, nil
+	}
+
+	lock, err := GetProviderInitLock(contextName, name)
+	if err != nil {
+		return "", err
+	}
+
+	locked, err := lock.TryLock()
+	if err != nil {
+		return "", fmt.Errorf("check init lock: %w", err)
+	}
+	if !locked {
+		return InitStateInitializing, nil
+	}
+	defer func() { _ = lock.Unlock() }()
+
+	if state != nil && state.InitAttempted {
+		// The lock is free but a prior attempt never reached Initialized:
+		// it either failed cleanly or was abandoned by a crashed process.
+		return InitStateFailed, nil
+	}
+
+	return InitStateNotInitialized, nil
+}
diff --git a/pkg/provider/initlock_test.go b/pkg/provider/initlock_test.go
new file mode 100644
index 000000000..29cf1588d
--- /dev/null
+++ b/pkg/provider/initlock_test.go
@@ -0,0 +1,86 @@
+package provider
+
+import (
+	"testing"
+
+	"github.com/devsy-org/devsy/pkg/config"
+)
+
+func useTempDevsyHome(t *testing.T) {
+	t.Helper()
+	t.Setenv(config.EnvHome, t.TempDir())
+	config.SetPathManager(config.NewPathManager())
+}
+
+func TestResolveInitState_NeverAttempted(t *testing.T) {
+	useTempDevsyHome(t)
+
+	got, err := ResolveInitState("default", "docker", &config.ProviderConfig{})
+	if err != nil {
+		t.Fatalf("ResolveInitState: %v", err)
+	}
+	if got != InitStateNotInitialized {
+		t.Fatalf("got %q, want %q", got, InitStateNotInitialized)
+	}
+}
+
+func TestResolveInitState_NilState(t *testing.T) {
+	useTempDevsyHome(t)
+
+	got, err := ResolveInitState("default", "docker", nil)
+	if err != nil {
+		t.Fatalf("ResolveInitState: %v", err)
+	}
+	if got != InitStateNotInitialized {
+		t.Fatalf("got %q, want %q", got, InitStateNotInitialized)
+	}
+}
+
+func TestResolveInitState_Initialized(t *testing.T) {
+	useTempDevsyHome(t)
+
+	got, err := ResolveInitState("default", "docker", &config.ProviderConfig{Initialized: true})
+	if err != nil {
+		t.Fatalf("ResolveInitState: %v", err)
+	}
+	if got != InitStateInitialized {
+		t.Fatalf("got %q, want %q", got, InitStateInitialized)
+	}
+}
+
+func TestResolveInitState_LiveLockHeldMeansInitializing(t *testing.T) {
+	useTempDevsyHome(t)
+
+	lock, err := GetProviderInitLock("default", "docker")
+	if err != nil {
+		t.Fatalf("GetProviderInitLock: %v", err)
+	}
+	locked, err := lock.TryLock()
+	if err != nil || !locked {
+		t.Fatalf("TryLock: locked=%v err=%v", locked, err)
+	}
+	defer func() { _ = lock.Unlock() }()
+
+	got, err := ResolveInitState("default", "docker", &config.ProviderConfig{InitAttempted: true})
+	if err != nil {
+		t.Fatalf("ResolveInitState: %v", err)
+	}
+	if got != InitStateInitializing {
+		t.Fatalf("got %q, want %q", got, InitStateInitializing)
+	}
+}
+
+func TestResolveInitState_FreeLockWithAttemptMeansFailed(t *testing.T) {
+	useTempDevsyHome(t)
+
+	// Simulate a crash mid-init: InitAttempted was persisted before the
+	// process died, but nothing holds the lock anymore since the OS released
+	// it when the process exited.
+	got, err := ResolveInitState("default", "docker", &config.ProviderConfig{InitAttempted: true})
+	if err != nil {
+		t.Fatalf("ResolveInitState: %v", err)
+	}
+	if got != InitStateFailed {
+		t.Fatalf("got %q, want %q", got, InitStateFailed)
+	}
+}
diff --git a/pkg/workspace/provider.go b/pkg/workspace/provider.go
index ce7dca684..c8de3ef47 100644
--- a/pkg/workspace/provider.go
+++ b/pkg/workspace/provider.go
@@ -21,6 +21,10 @@ var ErrNoWorkspaceFound = errors.New("no workspace found")
 type ProviderWithOptions struct {
 	Config *provider.ProviderConfig `json:"config,omitempty"`
 	State  *config.ProviderConfig   `json:"state,omitempty"`
+
+	// Status is the resolved init lifecycle state (not_initialized,
+	// initializing, initialized, failed). See provider.ResolveInitState.
+	Status provider.InitState `json:"status,omitempty"`
 }
 
 type ProviderParams struct {
@@ -64,6 +68,21 @@ func LoadAllProviders(
 		return nil, err
 	}
 
+	for name, entry := range retProviders {
+		status, err := provider.ResolveInitState(devsyConfig.DefaultContext, name, entry.State)
+		if err != nil {
+			log.Warnf("error resolving init state for provider %s: %v", name, err)
+			// Never leave Status empty: an unset value renders as a blank
+			// column and is dropped from JSON by omitempty.
+			if entry.State != nil && entry.State.Initialized {
+				status = provider.InitStateInitialized
+			} else {
+				status = provider.InitStateNotInitialized
+			}
+		}
+		entry.Status = status
+	}
+
 	return retProviders, nil
 }
 

From 716e2eda28a398a01c71594db2323ad7651182d4 Mon Sep 17 00:00:00 2001
From: Samuel K <skevetter@pm.me>
Date: Sat, 1 Aug 2026 14:01:43 -0500
Subject: [PATCH 2/5] style(provider): tidy comments and clarify lock
 synchronization

No mutex needed around the config mutation in initProvider: the flock
already serializes concurrent callers for the same provider, in-process
or across processes, since each call opens an independent file
description. Also trims verbose comments per review.
---
 cmd/provider/configure_shared.go | 10 ++++------
 pkg/config/config.go             | 16 +++++++---------
 pkg/provider/initlock.go         |  8 +++-----
 pkg/workspace/provider.go        |  5 +----
 4 files changed, 15 insertions(+), 24 deletions(-)

diff --git a/cmd/provider/configure_shared.go b/cmd/provider/configure_shared.go
index 8ebaf6920..c2e9ab6eb 100644
--- a/cmd/provider/configure_shared.go
+++ b/cmd/provider/configure_shared.go
@@ -203,9 +203,10 @@ func initProvider(
 	}
 	entry := devsyConfig.Current().Providers[provider.Name]
 
-	// Persist immediately so a concurrent `provider list` sees "initializing"
-	// for the duration of Exec.Init rather than waiting for the caller's final
-	// save at the end of ConfigureProvider.
+	// No mutex needed: the flock above already serializes concurrent callers
+	// for this provider, in-process or across processes. Persisted here (not
+	// deferred to ConfigureProvider's final save) so a concurrent
+	// `provider list` sees "initializing" for the duration of Exec.Init.
 	entry.InitAttempted = true
 	entry.InitError = ""
 	if err := config.SaveConfig(devsyConfig); err != nil {
@@ -237,9 +238,6 @@ func initProvider(
 	return nil
 }
 
-// maxInitErrorLen bounds how much of a failed init command's error we persist
-// to config.json, which (unlike interactive CLI/log output) may be synced,
-// backed up, or included in support bundles.
 const maxInitErrorLen = 500
 
 func truncateInitError(msg string) string {
diff --git a/pkg/config/config.go b/pkg/config/config.go
index e26d41594..4eca90d4b 100644
--- a/pkg/config/config.go
+++ b/pkg/config/config.go
@@ -73,17 +73,15 @@ type ProviderConfig struct {
 	// Initialized holds if the provider was initialized correctly.
 	Initialized bool `json:"initialized,omitempty"`
 
-	// InitAttempted holds if an initialization attempt has been started. Combined
-	// with the provider's init lock (see pkg/provider), this distinguishes "never
-	// initialized" from "an attempt started but didn't finish" (crashed or failed)
-	// when Initialized is false.
+	// InitAttempted holds if an initialization attempt has been started, used
+	// with the provider's init lock (see pkg/provider) to tell "never
+	// initialized" apart from "attempted but didn't finish" when Initialized
+	// is false.
 	InitAttempted bool `json:"initAttempted,omitempty"`
 
-	// InitError holds the error from the last failed initialization attempt,
-	// truncated to a bounded length since it's persisted to config.json (which
-	// may be synced or bundled for support) rather than kept in transient log
-	// output. Empty if the last attempt succeeded, was never run, or was
-	// abandoned by a crashed process (in which case InitAttempted is still true).
+	// InitError holds the truncated error from the last failed initialization
+	// attempt. Empty on success, if never run, or if abandoned by a crashed
+	// process.
 	InitError string `json:"initError,omitempty"`
 
 	// SingleMachine signals Devsy if a single machine should be used for this provider.
diff --git a/pkg/provider/initlock.go b/pkg/provider/initlock.go
index f545c4c54..95e018ca8 100644
--- a/pkg/provider/initlock.go
+++ b/pkg/provider/initlock.go
@@ -19,11 +19,9 @@ const (
 	InitStateFailed         InitState = "failed"
 )
 
-// GetProviderInitLock returns the advisory lock used to signal that a
-// provider's init command is currently running. Held for the duration of
-// Exec.Init in initProvider; ResolveInitState probes it (without blocking) to
-// tell a live "initializing" run apart from one abandoned by a crashed
-// process, since the OS releases the lock the moment that process dies.
+// GetProviderInitLock returns the advisory lock held while a provider's init
+// command runs, so ResolveInitState can tell a live "initializing" run apart
+// from one abandoned by a crashed process.
 func GetProviderInitLock(contextName, name string) (*flock.Flock, error) {
 	locksDir, err := GetLocksDir(contextName)
 	if err != nil {
diff --git a/pkg/workspace/provider.go b/pkg/workspace/provider.go
index 08534e019..e586df38a 100644
--- a/pkg/workspace/provider.go
+++ b/pkg/workspace/provider.go
@@ -21,10 +21,7 @@ var ErrNoWorkspaceFound = errors.New("no workspace found")
 type ProviderWithOptions struct {
 	Config *provider.ProviderConfig `json:"config,omitempty"`
 	State  *config.ProviderConfig   `json:"state,omitempty"`
-
-	// Status is the resolved init lifecycle state (not_initialized,
-	// initializing, initialized, failed). See provider.ResolveInitState.
-	Status provider.InitState `json:"status,omitempty"`
+	Status provider.InitState       `json:"status,omitempty"`
 }
 
 type ProviderParams struct {

From fdfe8f50adf2e38e51687d40ba9d084fa69ecc84 Mon Sep 17 00:00:00 2001
From: Samuel K <skevetter@pm.me>
Date: Sat, 1 Aug 2026 14:04:41 -0500
Subject: [PATCH 3/5] style(provider): drop remaining comments per review

---
 cmd/provider/configure_shared.go | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/cmd/provider/configure_shared.go b/cmd/provider/configure_shared.go
index c2e9ab6eb..53ab2c923 100644
--- a/cmd/provider/configure_shared.go
+++ b/cmd/provider/configure_shared.go
@@ -203,10 +203,6 @@ func initProvider(
 	}
 	entry := devsyConfig.Current().Providers[provider.Name]
 
-	// No mutex needed: the flock above already serializes concurrent callers
-	// for this provider, in-process or across processes. Persisted here (not
-	// deferred to ConfigureProvider's final save) so a concurrent
-	// `provider list` sees "initializing" for the duration of Exec.Init.
 	entry.InitAttempted = true
 	entry.InitError = ""
 	if err := config.SaveConfig(devsyConfig); err != nil {
@@ -224,10 +220,6 @@ func initProvider(
 	})
 	if runErr != nil {
 		entry.InitError = truncateInitError(runErr.Error())
-		// Best-effort: InitAttempted is already durably true from the save
-		// above, so ResolveInitState still reports "failed" once the deferred
-		// unlock releases the init lock even if this save fails; only the
-		// diagnostic InitError message would be lost.
 		if saveErr := config.SaveConfig(devsyConfig); saveErr != nil {
 			log.Warnf("save init failure state for provider %s: %v", provider.Name, saveErr)
 		}

From 2ec469e21bb917376e06c280cdb40a837265bd5c Mon Sep 17 00:00:00 2001
From: Samuel K <skevetter@pm.me>
Date: Sat, 1 Aug 2026 15:20:28 -0500
Subject: [PATCH 4/5] fix(provider): reset Initialized on retry, fix rune
 truncation, use read lock for probes

- initProvider left Initialized=true across a failed re-init, so a provider
  that previously succeeded reported "initialized" through a subsequent
  failed retry instead of "failed". Now reset alongside InitAttempted.
- truncateInitError sliced by byte index, which can split a multi-byte rune
  and produce invalid UTF-8. Truncate by rune count instead.
- ResolveInitState used an exclusive TryLock to merely probe the init lock,
  so two concurrent status reads could transiently report "initializing"
  for each other. Use TryRLock, which is compatible with other readers and
  still blocked by the exclusive lock initProvider holds while running.
---
 cmd/provider/configure_shared.go |  6 ++++--
 pkg/provider/initlock.go         |  2 +-
 pkg/provider/initlock_test.go    | 19 +++++++++++++++++++
 3 files changed, 24 insertions(+), 3 deletions(-)

diff --git a/cmd/provider/configure_shared.go b/cmd/provider/configure_shared.go
index 53ab2c923..b02d69930 100644
--- a/cmd/provider/configure_shared.go
+++ b/cmd/provider/configure_shared.go
@@ -205,6 +205,7 @@ func initProvider(
 
 	entry.InitAttempted = true
 	entry.InitError = ""
+	entry.Initialized = false
 	if err := config.SaveConfig(devsyConfig); err != nil {
 		return fmt.Errorf("save init state: %w", err)
 	}
@@ -233,8 +234,9 @@ func initProvider(
 const maxInitErrorLen = 500
 
 func truncateInitError(msg string) string {
-	if len(msg) <= maxInitErrorLen {
+	runes := []rune(msg)
+	if len(runes) <= maxInitErrorLen {
 		return msg
 	}
-	return msg[:maxInitErrorLen] + "…"
+	return string(runes[:maxInitErrorLen]) + "…"
 }
diff --git a/pkg/provider/initlock.go b/pkg/provider/initlock.go
index 95e018ca8..2c573ab62 100644
--- a/pkg/provider/initlock.go
+++ b/pkg/provider/initlock.go
@@ -47,7 +47,7 @@ func ResolveInitState(contextName, name string, state *config.ProviderConfig) (I
 		return "", err
 	}
 
-	locked, err := lock.TryLock()
+	locked, err := lock.TryRLock()
 	if err != nil {
 		return "", fmt.Errorf("check init lock: %w", err)
 	}
diff --git a/pkg/provider/initlock_test.go b/pkg/provider/initlock_test.go
index 29cf1588d..eb76b6c4b 100644
--- a/pkg/provider/initlock_test.go
+++ b/pkg/provider/initlock_test.go
@@ -70,6 +70,25 @@ func TestResolveInitState_LiveLockHeldMeansInitializing(t *testing.T) {
 	}
 }
 
+func TestResolveInitState_InitializedTakesPrecedenceOverInitError(t *testing.T) {
+	useTempDevsyHome(t)
+
+	// initProvider must reset Initialized to false before a retry runs, so
+	// this combination shouldn't occur on disk in practice. Locks in the
+	// intended precedence if it ever does: a stale Initialized=true still
+	// reads as initialized, since InitError alone is not a failure signal.
+	got, err := ResolveInitState("default", "docker", &config.ProviderConfig{
+		Initialized: true,
+		InitError:   "boom",
+	})
+	if err != nil {
+		t.Fatalf("ResolveInitState: %v", err)
+	}
+	if got != InitStateInitialized {
+		t.Fatalf("got %q, want %q", got, InitStateInitialized)
+	}
+}
+
 func TestResolveInitState_FreeLockWithAttemptMeansFailed(t *testing.T) {
 	useTempDevsyHome(t)
 

From 054a5730de062fcb433459bf0c4a26295d56833e Mon Sep 17 00:00:00 2001
From: Samuel K <skevetter@pm.me>
Date: Sat, 1 Aug 2026 15:22:10 -0500
Subject: [PATCH 5/5] style(provider): use ASCII ellipsis in truncated init
 error

---
 cmd/provider/configure_shared.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cmd/provider/configure_shared.go b/cmd/provider/configure_shared.go
index b02d69930..e09718277 100644
--- a/cmd/provider/configure_shared.go
+++ b/cmd/provider/configure_shared.go
@@ -238,5 +238,5 @@ func truncateInitError(msg string) string {
 	if len(runes) <= maxInitErrorLen {
 		return msg
 	}
-	return string(runes[:maxInitErrorLen]) + "…"
+	return string(runes[:maxInitErrorLen]) + "..."
 }