feat(agentsessions): import other coding agents' local sessions and continue them in Zero

internal/acp/agent.go

@@ -184,6 +184,12 @@ func (a *Agent) handleSessionLoad(ctx context.Context, params json.RawMessage) (
 	}
 	cwdInput := p.Cwd
 	if strings.TrimSpace(cwdInput) == "" {
+		// WorkspaceKey is populated from foreign transcript metadata. It is useful
+		// for matching/provenance, but it is not execution authority: only the ACP
+		// client may bind an imported session to a workspace tool boundary.
+		if strings.TrimSpace(meta.WorkspaceKey) != "" {
+			return nil, RPCError(codeInvalidParams, "cwd is required when loading an imported session")
+		}
 		cwdInput = meta.Cwd
 	}
 	root, err := a.deps.ResolveWorkspaceRoot(cwdInput)
@@ -198,7 +204,10 @@ func (a *Agent) handleSessionLoad(ctx context.Context, params json.RawMessage) (
 	if err != nil {
 		return nil, RPCError(codeInternalError, "config: "+err.Error())
 	}
-	if persistedModel := strings.TrimSpace(meta.ModelID); persistedModel != "" && (!restrictModels || modelChoiceExists(models, persistedModel)) {
+	persistedModel := strings.TrimSpace(meta.ModelID)
+	imported := sessions.IsImportedSession(*meta)
+	locallySelected := !imported || meta.ModelSelectedLocally
+	if persistedModel != "" && locallySelected && (!restrictModels || modelChoiceExists(models, persistedModel)) {
 		model = persistedModel
 		if !modelChoiceExists(models, persistedModel) {
 			models = append(models, SessionConfigOptionValue{Value: persistedModel, Name: persistedModel})

internal/acp/agent_test.go

@@ -323,6 +323,120 @@ func TestACPCustomProviderAllowsUnadvertisedModel(t *testing.T) {
 	}
 }
 
+func TestACPLoadImportedSessionDoesNotRestoreUnadvertisedForeignModel(t *testing.T) {
+	deps := testDeps(t)
+	deps.ResolveConfig = func(_ string, _ config.Overrides) (config.ResolvedConfig, error) {
+		return config.ResolvedConfig{Provider: config.ProviderProfile{
+			Name: "Custom", CatalogID: "custom-openai-compatible", Model: "workspace-model",
+		}}, nil
+	}
+	meta, err := deps.Store.Create(sessions.CreateInput{
+		Title:   "legacy imported session",
+		Cwd:     t.TempDir(),
+		ModelID: "foreign-expensive-model",
+		Tag:     sessions.ImportedSessionTag("claude-code", "foreign-id"),
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	h := newHarness(t, deps)
+	defer h.stop()
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	var loaded LoadSessionResult
+	if err := h.client.Call(ctx, MethodSessionLoad, LoadSessionParams{
+		SessionID: meta.SessionID,
+		Cwd:       t.TempDir(),
+	}, &loaded); err != nil {
+		t.Fatalf("session/load: %v", err)
+	}
+	option := loaded.ConfigOptions[0]
+	if option.CurrentValue != "workspace-model" || modelChoiceExists(option.Options, "foreign-expensive-model") {
+		t.Fatalf("imported model gained ACP authority: %+v", option)
+	}
+}
+
+func TestACPLoadImportedSessionRestoresLaterLocalModelSelection(t *testing.T) {
+	deps := testDeps(t)
+	deps.ResolveConfig = func(_ string, _ config.Overrides) (config.ResolvedConfig, error) {
+		return config.ResolvedConfig{Provider: config.ProviderProfile{
+			Name: "Custom", CatalogID: "custom-openai-compatible", Model: "workspace-model",
+		}}, nil
+	}
+	clientCwd := t.TempDir()
+	meta, err := deps.Store.Create(sessions.CreateInput{
+		Title:         "modern imported session",
+		Cwd:           "/foreign/display",
+		WorkspaceKey:  "/foreign/exact",
+		SourceModelID: "foreign-expensive-model",
+		Tag:           sessions.ImportedSessionTag("claude-code", "foreign-id"),
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	h := newHarness(t, deps)
+	var loaded LoadSessionResult
+	if err := h.client.Call(ctx, MethodSessionLoad, LoadSessionParams{SessionID: meta.SessionID, Cwd: clientCwd}, &loaded); err != nil {
+		t.Fatalf("initial session/load: %v", err)
+	}
+	if got := loaded.ConfigOptions[0].CurrentValue; got != "workspace-model" {
+		t.Fatalf("initial imported model = %q, want workspace default", got)
+	}
+	var selected SetSessionConfigOptionResult
+	if err := h.client.Call(ctx, MethodSessionSetConfigOption, SetSessionConfigOptionParams{
+		SessionID: meta.SessionID, ConfigID: configIDModel, Value: "local-choice",
+	}, &selected); err != nil {
+		t.Fatalf("set local model: %v", err)
+	}
+	if got := selected.ConfigOptions[0].CurrentValue; got != "local-choice" {
+		t.Fatalf("selected model = %q", got)
+	}
+	h.stop()
+
+	h = newHarness(t, deps)
+	defer h.stop()
+	loaded = LoadSessionResult{}
+	if err := h.client.Call(ctx, MethodSessionLoad, LoadSessionParams{SessionID: meta.SessionID, Cwd: clientCwd}, &loaded); err != nil {
+		t.Fatalf("fresh session/load: %v", err)
+	}
+	option := loaded.ConfigOptions[0]
+	if option.CurrentValue != "local-choice" || !modelChoiceExists(option.Options, "local-choice") {
+		t.Fatalf("fresh load discarded persisted local choice: %+v", option)
+	}
+}
+
+func TestACPLoadNativeImportedPrefixTagRestoresItsModel(t *testing.T) {
+	deps := testDeps(t)
+	deps.ResolveConfig = func(_ string, _ config.Overrides) (config.ResolvedConfig, error) {
+		return config.ResolvedConfig{Provider: config.ProviderProfile{
+			Name: "Custom", CatalogID: "custom-openai-compatible", Model: "workspace-model",
+		}}, nil
+	}
+	meta, err := deps.Store.Create(sessions.CreateInput{
+		Title:   "native archived session",
+		Cwd:     t.TempDir(),
+		ModelID: "native-model",
+		Tag:     "imported:archive",
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	h := newHarness(t, deps)
+	defer h.stop()
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	var loaded LoadSessionResult
+	if err := h.client.Call(ctx, MethodSessionLoad, LoadSessionParams{SessionID: meta.SessionID, Cwd: t.TempDir()}, &loaded); err != nil {
+		t.Fatalf("session/load: %v", err)
+	}
+	option := loaded.ConfigOptions[0]
+	if option.CurrentValue != "native-model" || !modelChoiceExists(option.Options, "native-model") {
+		t.Fatalf("native tagged model was discarded as foreign: %+v", option)
+	}
+}
+
 func TestACPModelDiscoveryFiltersProviderIncompatibleModels(t *testing.T) {
 	a := &Agent{deps: Deps{
 		ResolveConfig: func(string, config.Overrides) (config.ResolvedConfig, error) {
@@ -723,6 +837,45 @@ func TestACPLoadWarnsWhenHistoryReadFails(t *testing.T) {
 	}
 }
 
+func TestACPLoadImportedSessionRequiresClientWorkspace(t *testing.T) {
+	deps := testDeps(t)
+	displayCwd := "/work/[REDACTED]/repo"
+	foreignCwd := "/work/sk-ant-api03-AAAAAAAAAAAAAAAAAAAAAAAA/repo"
+	meta, err := deps.Store.Create(sessions.CreateInput{
+		Title:        "imported session",
+		Cwd:          displayCwd,
+		WorkspaceKey: foreignCwd,
+		Tag:          sessions.ImportedSessionTag("claude-code", "foreign-id"),
+	})
+	if err != nil {
+		t.Fatalf("create session: %v", err)
+	}
+	resolved := ""
+	deps.ResolveWorkspaceRoot = func(cwd string) (string, error) {
+		resolved = cwd
+		return cwd, nil
+	}
+	h := newHarness(t, deps)
+	defer h.stop()
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	if err := h.client.Call(ctx, MethodSessionLoad, LoadSessionParams{SessionID: meta.SessionID}, &LoadSessionResult{}); err == nil {
+		t.Fatal("session/load accepted an imported session without an ACP client workspace")
+	}
+	if resolved != "" {
+		t.Fatalf("foreign workspace reached resolver: %q", resolved)
+	}
+
+	clientCwd := t.TempDir()
+	if err := h.client.Call(ctx, MethodSessionLoad, LoadSessionParams{SessionID: meta.SessionID, Cwd: clientCwd}, &LoadSessionResult{}); err != nil {
+		t.Fatalf("session/load with client workspace: %v", err)
+	}
+	if resolved != clientCwd {
+		t.Fatalf("resolved workspace = %q, want ACP client workspace %q", resolved, clientCwd)
+	}
+}
+
 // drainText collects streamed chunks for a short window and concatenates them.
 func drainText(t *testing.T, ch <-chan string) string {
 	t.Helper()