packages/backend/internal/services/workspace_agent.go sha256=eeb7ea82245cca7104a4d92cc18b6a6832ed6bf7be160307023ba36f0e264eac lines=590-616

// resolveWorkspaceBookmark returns the requested bookmark (or the repository
// default when omitted) together with the repository default. Keeping both
// lets callers distinguish the reusable primary workspace from a derived
// bookmark workspace even when the repository default is not "main".
func (s *WorkspaceService) resolveWorkspaceBookmark(ctx context.Context, repositoryID int64, requested string) (string, string, error) {
	resolver, ok := s.q.(repositoryDefaultBookmarkResolver)
	if !ok {
		return "", "", pkgerrors.Internal("repository default bookmark resolver unavailable")
	}
	repo, err := resolver.GetRepoByID(ctx, repositoryID)
	if err != nil {
		return "", "", pkgerrors.Internal("load repository default bookmark: " + err.Error())
	}
	defaultBookmark := targetWorkspaceBookmark(repo.DefaultBookmark)
	bookmark := strings.TrimSpace(requested)
	if bookmark == "" {
		bookmark = defaultBookmark
	}
	return targetWorkspaceBookmark(bookmark), defaultBookmark, nil
}

packages/backend/internal/services/workspace_provisioning.go sha256=3cacaef3c6227d13ee27d62221e8dcc4a1126236dc70b45763f48ace42eb2bd2 lines=610-639
	}
	if s.runtime == nil && s.sandbox == nil {
		return WorkspaceResponse{}, pkgerrors.Internal("workspace runtime unavailable")
	}
	if err := validateWorkspaceCreateMetadata(input); err != nil {
		return WorkspaceResponse{}, err
	}
	kind, environment := workspaceCreateParamsMetadata(input)
	bookmark, defaultBookmark, err := s.resolveWorkspaceBookmark(ctx, input.RepositoryID, input.SourceBookmark)
	if err != nil {
		return WorkspaceResponse{}, err
	}
	input.SourceBookmark = bookmark

	var workspace db.Workspace

	if strings.TrimSpace(input.SnapshotID) == "" {
		if input.SourceRef != "" {
			workspace, err = s.createUserRefWorkspace(ctx, input, bookmark, workspaceCreateMetadata{kind: kind, environment: environment})
		} else if bookmark == defaultBookmark {
			workspace, err = s.findOrCreatePrimaryWorkspace(ctx, input.RepositoryID, input.UserID, strings.TrimSpace(input.Name), bookmark, workspaceCreateMetadata{kind: kind, environment: environment})
		} else {
			workspace, err = s.findOrCreateDerivedWorkspaceForBookmark(ctx, input.RepositoryID, input.UserID, strings.TrimSpace(input.Name), bookmark, workspaceCreateMetadata{kind: kind, environment: environment})
		}
		if err != nil {
			return WorkspaceResponse{}, err
		}
		if workspace, err = s.applyWorkspaceClientLease(ctx, workspace, input.ClientLeaseSeconds); err != nil {
			return WorkspaceResponse{}, err
		}

packages/backend/internal/services/workspace_provisioning.go sha256=3cacaef3c6227d13ee27d62221e8dcc4a1126236dc70b45763f48ace42eb2bd2 lines=663-686
	if err := s.refuseRebuildRequiredSnapshot(snapshot); err != nil {
		return WorkspaceResponse{}, err
	}
	if s.runtime != nil {
		if _, err := s.runtimeSnapshots(); err != nil {
			return WorkspaceResponse{}, err
		}
	}

	workspace, err = s.createWorkspaceRow(ctx, db.CreateWorkspaceParams{
		RepositoryID:           input.RepositoryID,
		UserID:                 input.UserID,
		Name:                   strings.TrimSpace(input.Name),
		IsFork:                 true,
		ParentWorkspaceID:      pgtype.UUID{},
		SourceSnapshotID:       stringToUUID(snapshot.ID),
		TargetBookmark:         bookmark,
		Kind:                   kind,
		EnvironmentSource:      environment.Source,
		EnvironmentRevision:    environment.Revision,
		EnvironmentClosureHash: environment.ClosureHash,
		Status:                 "starting",
	})
	if err != nil {

packages/backend/internal/services/workspace_provisioning.go sha256=3cacaef3c6227d13ee27d62221e8dcc4a1126236dc70b45763f48ace42eb2bd2 lines=1188-1196
func targetWorkspaceBookmark(bookmark string) string {
	if bookmark = strings.TrimSpace(bookmark); bookmark != "" {
		return bookmark
	}
	return "main"
}

func isPrimaryWorkspaceBookmark(bookmark string) bool {
	return targetWorkspaceBookmark(bookmark) == "main"

packages/backend/internal/routes/workspace.go sha256=f6e21f6830d135301e5fd3d318946fc896bdbdde389e0a4475d9afa9e0418393 lines=138-145

type createWorkspaceRequest struct {
	Name           string                        `json:"name"`
	SnapshotID     string                        `json:"snapshot_id"`
	SourceBookmark string                        `json:"source_bookmark,omitempty"`
	SourceRef      string                        `json:"source_ref,omitempty"` // a pushed ref of the caller (#1968)
	Kind           string                        `json:"kind,omitempty"`
	Environment    services.WorkspaceEnvironment `json:"environment,omitempty"`

apps/app/src/mainview/state/seams/WorkspaceSeam.ts sha256=688f4f46875df28a22ae7ea4a76daef9cf0d7264f76b3680b6eda121ee4a3042 lines=539-566
}

/*
 * One row of GET /api/user/workspaces: plue's UserWorkspaceRow
 * (internal/services/workspace.go — workspace_id, repository_owner,
 * repository_name, workspace_title, state), a switcher row that carries no
 * bookmark, stage, or suspension time. Those stay whatever the collection
 * already knows (the caller merges); they are never invented here.
 */
const parseUserWorkspaceWire = (value: unknown): CloudWorkspaceInput | null => {
  if (!isRecord(value)) return null
  const id = str(value.workspace_id)
  const owner = str(value.repository_owner)
  const repoName = str(value.repository_name)
  const name = str(value.workspace_title) ?? id
  if (id === null || owner === null || repoName === null || name === null || !isWorkspaceStatus(value.state)) return null
  return {
    id,
    repoId: `${owner}/${repoName}`,
    name,
    targetBookmark: null,
    status: value.state,
    /* plue#482: the switcher row states the failure too, so a failed row explains itself in the list. */
    failureCode: textOrNull(value.failure_code),
    failureMessage: textOrNull(value.failure_message),
    provisioningStage: null,
    suspendedAt: null,
    createdAt: textOrNull(value.created_at),

