fix(imports): align picker and child contracts

Author: gnanam1990

internal/agentsessions/registry.go

@@ -121,6 +121,30 @@ func ParseImportTag(tag string) (agent string, sourceID string, ok bool) {
 	return sessions.ParseImportedSessionTag(tag)
 }
 
+// ForeignSourceRefFromTag returns the display-level "agent:id" identity used
+// to suppress a foreign picker row after it has been imported. Unlike
+// ParseImportTag, this deliberately recognizes the legacy
+// "imported:<agent>:<plaintext id>" spelling written by older builds. It is
+// not an authority check: callers deciding whether a session may inherit
+// foreign state must continue to use the strict versioned parser.
+func ForeignSourceRefFromTag(tag string) (string, bool) {
+	if agent, sourceID, ok := ParseImportTag(tag); ok {
+		return agent + ":" + sourceID, true
+	}
+	trimmed := strings.TrimSpace(tag)
+	rest := strings.TrimPrefix(trimmed, importTagPrefix)
+	if rest == trimmed || strings.HasPrefix(rest, "v1:") {
+		return "", false
+	}
+	agent, sourceID, found := strings.Cut(rest, ":")
+	agent = strings.TrimSpace(agent)
+	sourceID = strings.TrimSpace(sourceID)
+	if !found || agent == "" || sourceID == "" {
+		return "", false
+	}
+	return agent + ":" + sourceID, true
+}
+
 // ImportedAgent is the agent a session was imported from, or "" for a session
 // Zero produced itself. Unlike ParseImportTag this accepts the older
 // "imported:<agent>" form, so sessions imported before the tag carried a source

internal/sessions/import_provenance.go

@@ -43,3 +43,17 @@ func IsImportedSession(metadata Metadata) bool {
 	_, _, ok := ParseImportedSessionTag(metadata.Tag)
 	return ok
 }
+
+// resolveImportedModelFields applies the imported-session model policy shared
+// by every lineage operation. Older imports stored the foreign model in the
+// operational ModelID field. Unless Zero has explicitly selected that model,
+// descendants retain it as provenance only.
+func resolveImportedModelFields(parent Metadata) (modelID, sourceModelID string) {
+	modelID = parent.ModelID
+	sourceModelID = parent.SourceModelID
+	if IsImportedSession(parent) && sourceModelID == "" && !parent.ModelSelectedLocally {
+		sourceModelID = modelID
+		modelID = ""
+	}
+	return modelID, sourceModelID
+}

internal/sessions/lineage.go

@@ -25,14 +25,16 @@ func (store *Store) CreateChild(parentSessionID string, input ChildInput) (Metad
 	if len(parentEvents) > 0 {
 		lastParentEvent = parentEvents[len(parentEvents)-1]
 	}
+	parentModelID, sourceModelID := resolveImportedModelFields(*parent)
 
 	child, err := store.Create(CreateInput{
 		SessionID:           input.SessionID,
 		SessionKind:         SessionKindChild,
 		Title:               childTitle(input.Title, input.AgentName, parent.Title),
 		Cwd:                 firstNonEmpty(input.Cwd, parent.Cwd),
 		WorkspaceKey:        derivedWorkspaceKey(input.Cwd, parent.WorkspaceKey),
-		ModelID:             firstNonEmpty(input.ModelID, parent.ModelID),
+		ModelID:             firstNonEmpty(input.ModelID, parentModelID),
+		SourceModelID:       sourceModelID,
 		Provider:            firstNonEmpty(input.Provider, parent.Provider),
 		Tag:                 input.Tag,
 		Depth:               input.Depth,

internal/sessions/store.go

@@ -534,15 +534,7 @@ func (store *Store) Fork(parentSessionID string, input ForkInput) (Metadata, err
 	if kind != SessionKindFork && kind != SessionKindSide {
 		return Metadata{}, fmt.Errorf("invalid zero fork session kind %q", kind)
 	}
-	parentModelID := parent.ModelID
-	sourceModelID := parent.SourceModelID
-	if IsImportedSession(*parent) && sourceModelID == "" && !parent.ModelSelectedLocally {
-		// Older imports stored the foreign model in the operational field. A new
-		// fork must migrate that value to provenance instead of inheriting it as a
-		// local provider choice.
-		sourceModelID = parentModelID
-		parentModelID = ""
-	}
+	parentModelID, sourceModelID := resolveImportedModelFields(*parent)
 	fork, err := store.Create(CreateInput{
 		SessionID:          input.SessionID,
 		SessionKind:        kind,

internal/sessions/store_test.go

@@ -201,6 +201,70 @@ func TestNativeImportedPrefixTagRetainsOperationalModelOnFork(t *testing.T) {
 	}
 }
 
+func TestCreateChildMigratesImportedParentModelProvenance(t *testing.T) {
+	for _, tc := range []struct {
+		name              string
+		parentModel       string
+		parentSourceModel string
+		selectLocalModel  string
+		childModel        string
+		wantModel         string
+		wantSourceModel   string
+	}{
+		{
+			name:            "legacy foreign model is provenance only",
+			parentModel:     "foreign-model",
+			wantSourceModel: "foreign-model",
+		},
+		{
+			name:            "explicit child model overrides migrated parent",
+			parentModel:     "foreign-model",
+			childModel:      "specialist-model",
+			wantModel:       "specialist-model",
+			wantSourceModel: "foreign-model",
+		},
+		{
+			name:              "locally selected parent model remains operational",
+			parentSourceModel: "foreign-model",
+			selectLocalModel:  "zero-local-model",
+			wantModel:         "zero-local-model",
+			wantSourceModel:   "foreign-model",
+		},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			store := NewStore(StoreOptions{RootDir: t.TempDir()})
+			parent, err := store.Create(CreateInput{
+				SessionID:     "imported-parent",
+				Tag:           ImportedSessionTag("claude-code", "foreign-id"),
+				ModelID:       tc.parentModel,
+				SourceModelID: tc.parentSourceModel,
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if tc.selectLocalModel != "" {
+				parent, err = store.UpdateModel(parent.SessionID, tc.selectLocalModel)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if !parent.ModelSelectedLocally {
+					t.Fatal("imported parent did not retain the local-selection authority bit")
+				}
+			}
+			child, err := store.CreateChild(parent.SessionID, ChildInput{
+				SessionID: "child",
+				ModelID:   tc.childModel,
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if child.ModelID != tc.wantModel || child.SourceModelID != tc.wantSourceModel {
+				t.Fatalf("child model fields = (%q, %q), want (%q, %q)", child.ModelID, child.SourceModelID, tc.wantModel, tc.wantSourceModel)
+			}
+		})
+	}
+}
+
 func TestStoreForkSupportsNonResumableSideSession(t *testing.T) {
 	store := NewStore(StoreOptions{RootDir: t.TempDir()})
 	parent, err := store.Create(CreateInput{SessionID: "parent", Title: "Parent"})

internal/tui/session.go

@@ -256,11 +256,8 @@ func (m model) sessionPickerCmd() (model, tea.Cmd) {
 		now:              m.now,
 	}
 	return m, func() tea.Msg {
-		picker, localErr := snapshot.buildSessionPicker()
-		warning := ""
-		if localErr != nil {
-			warning = "Sessions\nWarning: could not read local Zero sessions; showing external sessions only: " + agentsessions.DisplayField(localErr.Error())
-		}
+		picker, foreignProblems, localErr := snapshot.buildSessionPicker()
+		warning := sessionPickerWarning(localErr, foreignProblems)
 		msg := sessionPickerLoadedMsg{originSession: originSession, generation: generation}
 		if picker != nil {
 			msg.picker, msg.text = picker, warning
@@ -275,6 +272,28 @@ func (m model) sessionPickerCmd() (model, tea.Cmd) {
 	}
 }
 
+// sessionPickerWarning keeps partial discovery failures visible without
+// turning them into a failed picker. Errors may contain paths or transcript
+// identifiers from foreign stores, so this is also the single display
+// boundary that sanitizes every local and foreign problem before it reaches
+// the terminal transcript.
+func sessionPickerWarning(localErr error, foreignProblems []error) string {
+	warnings := []string{}
+	if localErr != nil {
+		warnings = append(warnings, "Warning: could not read local Zero sessions; showing external sessions only: "+agentsessions.DisplayField(localErr.Error()))
+	}
+	for _, problem := range foreignProblems {
+		if problem == nil {
+			continue
+		}
+		warnings = append(warnings, "Warning: could not read some external sessions: "+agentsessions.DisplayField(problem.Error()))
+	}
+	if len(warnings) == 0 {
+		return ""
+	}
+	return "Sessions\n" + strings.Join(warnings, "\n")
+}
+
 // sessionPickerResultIsCurrent reports whether a discovery result still
 // describes a request whose preconditions hold: no run has started, the same
 // session is active, and no newer /resume has replaced it.
@@ -495,16 +514,17 @@ func sessionWhenTime(parsed time.Time, now time.Time) string {
 // one row per resumable session — title (Label) + id and relative age (Meta). Returns
 // nil when there are no resumable sessions so the caller falls back to the text path.
 func (m model) newSessionPicker() *commandPicker {
-	picker, _ := m.buildSessionPicker()
+	picker, _, _ := m.buildSessionPicker()
 	return picker
 }
 
 // buildSessionPicker keeps the local and external sources independent. A local
-// store failure removes only local rows; callers receive the error separately
-// so they can warn without hiding discoverable external work.
-func (m model) buildSessionPicker() (*commandPicker, error) {
+// store failure removes only local rows; callers receive local and foreign
+// problems separately so they can warn without hiding discoverable work from
+// the sources that did succeed.
+func (m model) buildSessionPicker() (*commandPicker, []error, error) {
 	if m.sessionStore == nil {
-		return nil, nil
+		return nil, nil, nil
 	}
 	// A FAILED READ IS THE ONLY REASON TO GIVE UP HERE. An EMPTY local history is
 	// not: foreign sessions are discovered independently of the store, and the
@@ -555,7 +575,8 @@ func (m model) buildSessionPicker() (*commandPicker, error) {
 			Tab:  agent,
 		})
 	}
-	return pickerFromParts(items, m.foreignSessionItems(metas, now)), err
+	foreign, problems := m.foreignSessionItems(metas, now)
+	return pickerFromParts(items, foreign), problems, err
 }
 
 // pickerFromParts assembles the picker from the two independent sources, and
@@ -674,8 +695,9 @@ func importedSessionNote(result agentsessions.ImportResult, workspace string) st
 //
 // Reading these is a bounded index of each transcript's head, never the whole
 // file (see internal/agentsessions). A store that is missing or has changed
-// shape contributes nothing rather than failing the picker — /resume must still
-// open on a machine where one vendor shipped a new format this morning.
+// shape contributes a caller-visible problem rather than failing the picker —
+// /resume must still open on a machine where one vendor shipped a new format
+// this morning, without pretending the partial index is complete.
 // importedSourceRefs is the set of foreign sessions that have actually been
 // imported, so the picker can skip offering them a second time — listing a
 // session twice, once as itself and once as its copy, is worse than not offering
@@ -700,17 +722,17 @@ func importedSourceRefs(existing []sessions.Metadata) map[string]bool {
 		if meta.EventCount == 0 {
 			continue
 		}
-		if agent, sourceID, ok := agentsessions.ParseImportTag(meta.Tag); ok {
-			imported[agent+":"+sourceID] = true
+		if ref, ok := agentsessions.ForeignSourceRefFromTag(meta.Tag); ok {
+			imported[ref] = true
 		}
 	}
 	return imported
 }
 
-func (m model) foreignSessionItems(existing []sessions.Metadata, now time.Time) []pickerItem {
+func (m model) foreignSessionItems(existing []sessions.Metadata, now time.Time) ([]pickerItem, []error) {
 	imported := importedSourceRefs(existing)
 
-	found, _ := agentsessions.DiscoverAllCached(m.agentSessionsEnv, m.cwd)
+	found, problems := agentsessions.DiscoverAllCached(m.agentSessionsEnv, m.cwd)
 	items := make([]pickerItem, 0, len(found))
 	for _, session := range found {
 		ref := session.Agent + ":" + session.ID
@@ -736,7 +758,7 @@ func (m model) foreignSessionItems(existing []sessions.Metadata, now time.Time)
 			ForeignSource: &source,
 		})
 	}
-	return items
+	return items, problems
 }
 
 // sessionAgentName is the agent a session came from, for the picker's tab strip.

internal/tui/session_import_note_test.go

@@ -75,7 +75,7 @@ func TestForeignResumeCanRetryAnEmptyTranslationWithoutCreatingSessions(t *testi
 	}
 
 	agentsessions.InvalidateDiscovery()
-	items := m.foreignSessionItems(nil, time.Now())
+	items, _ := m.foreignSessionItems(nil, time.Now())
 	if len(items) != 1 || items[0].Value != "claude-code:empty" {
 		t.Fatalf("retryable foreign source disappeared from the picker: %+v", items)
 	}